From d7b0fff95404a26df979aba24153e1c3ef4c01bb Mon Sep 17 00:00:00 2001 From: Luis Novo Date: Thu, 17 Jul 2025 08:36:11 -0300 Subject: [PATCH] Api podcast migration (#93) Creates the API layer for Open Notebook Creates a services API gateway for the Streamlit front-end Migrates the SurrealDB SDK to the official one Change all database calls to async New podcast framework supporting multiple speaker configurations Implement the surreal-commands library for async processing Improve docker image and docker-compose configurations --- .claude/CLAUDE.md | 121 + .../api_troubleshoot/migration_plan.md | 319 ++ .../migrate_surrealdb/architecture.md | 358 ++ .claude/sessions/migrate_surrealdb/context.md | 110 + .claude/sessions/migrate_surrealdb/plan.md | 898 +++++ .../migrate_surrealdb/requirements.txt | 15 + .claude/sessions/oss-136/architecture.md | 454 +++ .claude/sessions/oss-136/context.md | 133 + .claude/sessions/oss-136/plan.md | 1795 ++++++++++ .claude/sessions/oss-136/test.md | 5 + .claude/sessions/podcast_page/architecture.md | 321 ++ .claude/sessions/podcast_page/context.md | 74 + .claude/sessions/podcast_page/plan.md | 398 +++ .../sessions/podcast_page/requirements.txt | 56 + .dockerignore | 43 +- .env.example | 18 +- .gitignore | 7 +- .streamlit/config.toml | 2 +- Dockerfile | 53 +- Dockerfile.single | 68 +- Makefile | 151 +- README.md | 170 +- api/__init__.py | 0 api/auth.py | 96 + api/client.py | 405 +++ api/command_service.py | 92 + api/context_service.py | 32 + api/embedding_service.py | 25 + api/episode_profiles_service.py | 102 + api/insights_service.py | 82 + api/main.py | 76 + api/models.py | 264 ++ api/models_service.py | 97 + api/notebook_service.py | 84 + api/notes_service.py | 97 + api/podcast_api_service.py | 123 + api/podcast_service.py | 204 ++ api/routers/__init__.py | 0 api/routers/commands.py | 160 + api/routers/context.py | 118 + api/routers/embedding.py | 69 + api/routers/episode_profiles.py | 262 ++ api/routers/insights.py | 82 + api/routers/models.py | 153 + api/routers/notebooks.py | 140 + api/routers/notes.py | 168 + api/routers/podcasts.py | 183 + api/routers/search.py | 213 ++ api/routers/settings.py | 62 + api/routers/sources.py | 310 ++ api/routers/speaker_profiles.py | 222 ++ api/routers/transformations.py | 210 ++ api/search_service.py | 56 + api/settings_service.py | 57 + api/sources_service.py | 183 + api/transformations_service.py | 124 + app_home.py | 19 +- commands/__init__.py | 10 + commands/example_commands.py | 149 + commands/podcast_commands.py | 195 ++ docker-compose.single.yml | 20 + docker-compose.yml | 22 +- docs/PODCASTS.md | 2 - docs/SETUP.md | 1 - docs/TRANSFORMATIONS.md | 50 +- docs/USAGE.md | 2 - docs/ai-notes.md | 27 + docs/basic-workflow.md | 64 + docs/chat-assistant.md | 13 + docs/content-support.md | 123 + docs/model-providers.md | 180 + docs/models.md | 3 +- docs/podcast.md | 166 + docs/search.md | 42 + docs/security.md | 133 + docs/single-container-deployment.md | 195 ++ migrations/7.surrealql | 152 + migrations/7_down.surrealql | 3 + open_notebook/config.py | 15 - open_notebook/database/async_migrate.py | 184 + open_notebook/database/migrate.py | 74 +- open_notebook/database/new.py | 178 + open_notebook/database/repository.py | 193 +- open_notebook/database/repository_old.py | 63 + open_notebook/domain/base.py | 115 +- open_notebook/domain/content_settings.py | 6 +- open_notebook/domain/models.py | 78 +- open_notebook/domain/notebook.py | 209 +- open_notebook/domain/podcast.py | 148 + open_notebook/graphs/ask.py | 20 +- open_notebook/graphs/chat.py | 17 +- open_notebook/graphs/prompt.py | 7 +- open_notebook/graphs/source.py | 13 +- open_notebook/graphs/transformation.py | 14 +- open_notebook/graphs/utils.py | 8 +- open_notebook/plugins/podcasts.py | 4 +- open_notebook/utils.py | 21 - open_notebook_config.yaml | 57 - pages/10_⚙️_Settings.py | 184 +- pages/2_📒_Notebooks.py | 22 +- pages/3_🔍_Ask_and_Search.py | 114 +- pages/5_🎙️_Podcasts.py | 1615 +++++++-- pages/7_🤖_Models.py | 73 +- pages/8_💱_Transformations.py | 27 +- pages/components/__init__.py | 2 - pages/components/model_selector.py | 6 +- pages/components/note_panel.py | 28 +- pages/components/source_embedding_panel.py | 17 - pages/components/source_insight.py | 17 +- pages/components/source_panel.py | 82 +- pages/stream_app/auth.py | 52 + pages/stream_app/chat.py | 185 +- pages/stream_app/note.py | 33 +- pages/stream_app/source.py | 72 +- pages/stream_app/utils.py | 31 +- pyproject.toml | 13 +- run_api.py | 31 + setup_guide/DOCKER_SETUP_ADVANCED.md | 283 ++ setup_guide/README.md | 280 ++ setup_guide/docker-compose.yml | 12 + setup_guide/docker.env | 13 + supervisord.conf | 22 +- supervisord.single.conf | 49 + test_commands.sh | 90 + uv.lock | 3005 +++++------------ 125 files changed, 16177 insertions(+), 3296 deletions(-) create mode 100644 .claude/CLAUDE.md create mode 100644 .claude/sessions/api_troubleshoot/migration_plan.md create mode 100644 .claude/sessions/migrate_surrealdb/architecture.md create mode 100644 .claude/sessions/migrate_surrealdb/context.md create mode 100644 .claude/sessions/migrate_surrealdb/plan.md create mode 100644 .claude/sessions/migrate_surrealdb/requirements.txt create mode 100644 .claude/sessions/oss-136/architecture.md create mode 100644 .claude/sessions/oss-136/context.md create mode 100644 .claude/sessions/oss-136/plan.md create mode 100644 .claude/sessions/oss-136/test.md create mode 100644 .claude/sessions/podcast_page/architecture.md create mode 100644 .claude/sessions/podcast_page/context.md create mode 100644 .claude/sessions/podcast_page/plan.md create mode 100644 .claude/sessions/podcast_page/requirements.txt create mode 100644 api/__init__.py create mode 100644 api/auth.py create mode 100644 api/client.py create mode 100644 api/command_service.py create mode 100644 api/context_service.py create mode 100644 api/embedding_service.py create mode 100644 api/episode_profiles_service.py create mode 100644 api/insights_service.py create mode 100644 api/main.py create mode 100644 api/models.py create mode 100644 api/models_service.py create mode 100644 api/notebook_service.py create mode 100644 api/notes_service.py create mode 100644 api/podcast_api_service.py create mode 100644 api/podcast_service.py create mode 100644 api/routers/__init__.py create mode 100644 api/routers/commands.py create mode 100644 api/routers/context.py create mode 100644 api/routers/embedding.py create mode 100644 api/routers/episode_profiles.py create mode 100644 api/routers/insights.py create mode 100644 api/routers/models.py create mode 100644 api/routers/notebooks.py create mode 100644 api/routers/notes.py create mode 100644 api/routers/podcasts.py create mode 100644 api/routers/search.py create mode 100644 api/routers/settings.py create mode 100644 api/routers/sources.py create mode 100644 api/routers/speaker_profiles.py create mode 100644 api/routers/transformations.py create mode 100644 api/search_service.py create mode 100644 api/settings_service.py create mode 100644 api/sources_service.py create mode 100644 api/transformations_service.py create mode 100644 commands/__init__.py create mode 100644 commands/example_commands.py create mode 100644 commands/podcast_commands.py create mode 100644 docker-compose.single.yml delete mode 100644 docs/PODCASTS.md delete mode 100644 docs/SETUP.md delete mode 100644 docs/USAGE.md create mode 100644 docs/ai-notes.md create mode 100644 docs/basic-workflow.md create mode 100644 docs/chat-assistant.md create mode 100644 docs/content-support.md create mode 100644 docs/model-providers.md create mode 100644 docs/podcast.md create mode 100644 docs/search.md create mode 100644 docs/security.md create mode 100644 docs/single-container-deployment.md create mode 100644 migrations/7.surrealql create mode 100644 migrations/7_down.surrealql create mode 100644 open_notebook/database/async_migrate.py create mode 100644 open_notebook/database/new.py create mode 100644 open_notebook/database/repository_old.py create mode 100644 open_notebook/domain/podcast.py delete mode 100644 open_notebook_config.yaml delete mode 100644 pages/components/source_embedding_panel.py create mode 100644 pages/stream_app/auth.py create mode 100644 run_api.py create mode 100644 setup_guide/DOCKER_SETUP_ADVANCED.md create mode 100644 setup_guide/README.md create mode 100644 setup_guide/docker-compose.yml create mode 100644 setup_guide/docker.env create mode 100644 supervisord.single.conf create mode 100755 test_commands.sh diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md new file mode 100644 index 0000000..e960b98 --- /dev/null +++ b/.claude/CLAUDE.md @@ -0,0 +1,121 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +Open Notebook is an open-source, privacy-focused alternative to Google's Notebook LM. It's a research assistant that allows users to manage research, generate AI-assisted notes, and interact with content through Streamlit UI and REST API, backed by SurrealDB. + +## Development Commands + +### Environment Setup +```bash +# Copy environment templates +cp .env.example .env +cp .env.example docker.env + +# Install dependencies +uv sync +uv pip install python-magic +``` + +### Running the Application +```bash +# Start SurrealDB (required) +make database +# or: docker compose up -d surrealdb + +# Start API backend (port 5055) +make api +# or: uv run run_api.py +# or: uv run --env-file .env uvicorn api.main:app --host 0.0.0.0 --port 5055 + +# Start Streamlit UI (port 8502) +make run +# or: uv run --env-file .env streamlit run app_home.py +``` + +### Code Quality +```bash +# Run linter with auto-fix +make ruff +# or: ruff check . --fix + +# Run type checking +make lint +# or: uv run python -m mypy . +``` + +### Docker Commands +```bash +# Full stack deployment +docker compose --profile multi up + +# Build multi-platform image +make docker-build + +# Release with version tag +make docker-release +``` + +## Architecture Overview + +### Three-Layer Architecture +1. **Frontend**: Streamlit UI (`app_home.py` and `/pages/`) +2. **API**: FastAPI backend (`/api/`) on port 5055 +3. **Database**: SurrealDB graph database + +### Key Directories +- `/open_notebook/domain/`: Domain models (notebook, models, transformation) +- `/open_notebook/graphs/`: LangGraph processing (chat, ask, source, transformation) +- `/open_notebook/database/`: SurrealDB repository pattern +- `/api/`: REST API endpoints +- `/pages/`: Streamlit UI pages +- `/migrations/`: Database migrations + +### Data Storage +- `/data/uploads/`: User-uploaded files +- `/data/podcasts/`: Generated podcasts +- `/data/sqlite-db/`: LangGraph checkpoints +- `/surreal_data/`: SurrealDB files + +## AI Provider Integration + +The project uses the Esperanto library for multi-provider AI support: +- Language models: OpenAI, Anthropic, Google, Groq, Ollama, Mistral, DeepSeek, xAI, OpenRouter +- Embeddings: OpenAI, Google, Ollama, Mistral, Voyage +- Speech: OpenAI, Groq, ElevenLabs, Google TTS + +Model configuration is centralized through `ModelManager` class in `/open_notebook/domain/models.py`. + +## Database Operations + +Uses SurrealDB with async operations: +```python +# Create record +await repo_create(table: str, data: dict) + +# Upsert (merge) record +await repo_upsert(table: str, record_id: Union[str, RecordID], data: dict) + +# Query +await repo_query("SELECT * FROM table WHERE field = $value", {"value": "example"}) + +# Delete +await repo_delete(record_id) +``` + +## Content Processing Pipeline + +1. Content ingestion (files, URLs, text) via `/open_notebook/graphs/source.py` +2. Text extraction using Content-Core library +3. Embedding generation for semantic search +4. Transformation workflows in `/open_notebook/graphs/transformation.py` + +## Testing Approach + +Check README or search codebase for test configuration before running tests. The project uses `uv` for all Python operations. + +## API Documentation + +Interactive API docs available at http://localhost:5055/docs when API is running. Comprehensive endpoints for notebooks, sources, notes, search, models, transformations, and embeddings. \ No newline at end of file diff --git a/.claude/sessions/api_troubleshoot/migration_plan.md b/.claude/sessions/api_troubleshoot/migration_plan.md new file mode 100644 index 0000000..61531fe --- /dev/null +++ b/.claude/sessions/api_troubleshoot/migration_plan.md @@ -0,0 +1,319 @@ +# API Migration Plan: Direct Domain Calls to API Calls + +## Project Context + +The Open Notebook project has undergone a significant architectural migration from direct domain model access to a proper API-based architecture. The project consists of: + +1. **Domain Layer**: Core business logic and data models (in `open_notebook/domain/`) +2. **API Layer**: FastAPI-based REST API endpoints (in `api/`) +3. **Streamlit Frontend**: User interface components (in `pages/`) + +During the development process, a comprehensive API layer was built to provide proper separation of concerns, better error handling, and standardized interfaces. However, it appears that some Streamlit components were not fully migrated to use the API layer and are still making direct calls to domain models using `asyncio.run()`. + +This creates several issues: +- **Architectural inconsistency**: Some parts use APIs while others bypass them +- **Potential data consistency problems**: Direct domain calls might bypass API validation and business logic +- **Maintenance difficulties**: Changes to domain models could break Streamlit components unexpectedly +- **Performance issues**: Direct async calls in Streamlit can cause blocking behavior + +## Migration Strategy + +This document systematically identifies every instance where Streamlit components directly call domain models and provides the exact API replacement. The goal is to ensure that ALL frontend interactions go through the API layer, maintaining proper architectural boundaries. + +## Overview +This document maps all instances where the Streamlit app is directly calling domain models instead of using the API layer. Each entry includes the current implementation and the recommended API replacement. + +## Migration Mappings + +### 1. **pages/components/source_panel.py** + +#### Line 18: Get Source by ID +**Current:** +```python +source: Source = asyncio.run(Source.get(source_id)) +``` +**Should be:** +```python +from api.client import api_client +source = api_client.get_source(source_id) +``` +**API Endpoint:** `GET /api/sources/{source_id}` + +#### Line 62: Get All Transformations +**Current:** +```python +transformations = asyncio.run(Transformation.get_all(order_by="name asc")) +``` +**Should be:** +```python +from api.transformations_service import transformations_service +transformations = transformations_service.get_all_transformations() +``` +**API Endpoint:** `GET /api/transformations` + +#### Line 83: Get Embedding Model +**Current:** +```python +embedding_model = asyncio.run(model_manager.get_embedding_model()) +``` +**Should be:** +```python +from api.models_service import models_service +default_models = models_service.get_default_models() +embedding_model = default_models.get("embedding") +``` +**API Endpoint:** `GET /api/models/defaults` + +#### Line 91: Check Embedded Chunks +**Current:** +```python +if not asyncio.run(source.get_embedded_chunks()) and st.button( +``` +**Should be:** +```python +# Use the source object already fetched from API that includes embedded_chunks field +if not source.embedded_chunks and st.button( +``` +**API Endpoint:** `GET /api/sources/{source_id}` (uses embedded_chunks field) + +### 2. **pages/components/note_panel.py** + +#### Line 16: Get Embedding Model +**Current:** +```python +if not asyncio.run(model_manager.get_embedding_model()): +``` +**Should be:** +```python +from api.models_service import models_service +default_models = models_service.get_default_models() +if not default_models.get("embedding"): +``` +**API Endpoint:** `GET /api/models/defaults` + +#### Line 20: Get Note by ID +**Current:** +```python +note: Note = asyncio.run(Note.get(note_id)) +``` +**Should be:** +```python +from api.client import api_client +note = api_client.get_note(note_id) +``` +**API Endpoint:** `GET /api/notes/{note_id}` + +### 3. **pages/components/model_selector.py** + +#### Line 21: Get Models by Type +**Current:** +```python +models = asyncio.run(Model.get_models_by_type(model_type)) +``` +**Should be:** +```python +from api.models_service import models_service +models = models_service.get_models(type=model_type) +``` +**API Endpoint:** `GET /api/models?type={model_type}` + +### 4. **pages/stream_app/utils.py** + +#### Line 122: Get Default Models Instance +**Current:** +```python +default_models = asyncio.run(DefaultModels.get_instance()) +``` +**Should be:** +```python +from api.models_service import models_service +default_models = models_service.get_default_models() +``` +**API Endpoint:** `GET /api/models/defaults` + +### 5. **pages/stream_app/chat.py** + +#### Line 89: Get All Episode Profiles +**Current:** +```python +episode_profiles = asyncio.run(EpisodeProfile.get_all()) +``` +**Should be:** +```python +from api.client import api_client +episode_profiles = api_client.get_episode_profiles() +``` +**API Endpoint:** `GET /api/episode-profiles` + +### 6. **pages/stream_app/source.py** + +#### Line 30: Get Speech to Text Model +**Current:** +```python +if not asyncio.run(model_manager.get_speech_to_text()): +``` +**Should be:** +```python +from api.models_service import models_service +default_models = models_service.get_default_models() +if not default_models.get("speech_to_text"): +``` +**API Endpoint:** `GET /api/models/defaults` + +#### Line 40: Get All Transformations +**Current:** +```python +transformations = asyncio.run(Transformation.get_all()) +``` +**Should be:** +```python +from api.transformations_service import transformations_service +transformations = transformations_service.get_all_transformations() +``` +**API Endpoint:** `GET /api/transformations` + +#### Line 167: Get Source Insights +**Current:** +```python +insights = asyncio.run(source.get_insights()) +``` +**Should be:** +```python +from api.insights_service import insights_service +insights = insights_service.get_source_insights(source.id) +``` +**API Endpoint:** `GET /api/sources/{source_id}/insights` + +### 7. **pages/stream_app/note.py** + +#### Line 20: Get Embedding Model +**Current:** +```python +if not asyncio.run(model_manager.get_embedding_model()): +``` +**Should be:** +```python +from api.models_service import models_service +default_models = models_service.get_default_models() +if not default_models.get("embedding"): +``` +**API Endpoint:** `GET /api/models/defaults` + +### 7. **pages/3_🔍_Ask_and_Search.py** + +#### Line 66: Get Embedding Model +**Current:** +```python +embedding_model = asyncio.run(model_manager.get_embedding_model()) +``` +**Should be:** +```python +from api.models_service import models_service +default_models = models_service.get_default_models() +embedding_model = default_models.get("embedding") +``` +**API Endpoint:** `GET /api/models/defaults` + +### 8. **pages/2_📒_Notebooks.py** + +#### Line 75: Get Notebook Sources +**Current:** +```python +sources = asyncio.run(current_notebook.get_sources()) +``` +**Should be:** +```python +from api.sources_service import sources_service +sources = sources_service.get_sources(notebook_id=current_notebook.id) +``` +**API Endpoint:** `GET /api/sources?notebook_id={notebook_id}` + +#### Line 76: Get Notebook Notes +**Current:** +```python +notes = asyncio.run(current_notebook.get_notes()) +``` +**Should be:** +```python +from api.notes_service import notes_service +notes = notes_service.get_notes(notebook_id=current_notebook.id) +``` +**API Endpoint:** `GET /api/notes?notebook_id={notebook_id}` + +### 9. **pages/5_🎙️_Podcasts.py** + +#### Line 428: Get Text to Speech Models +**Current:** +```python +text_to_speech_models = asyncio.run(Model.get_models_by_type("text_to_speech")) +``` +**Should be:** +```python +from api.models_service import models_service +text_to_speech_models = models_service.get_models(type="text_to_speech") +``` +**API Endpoint:** `GET /api/models?type=text_to_speech` + +#### Line 429: Get Language Models +**Current:** +```python +text_models = asyncio.run(Model.get_models_by_type("language")) +``` +**Should be:** +```python +from api.models_service import models_service +text_models = models_service.get_models(type="language") +``` +**API Endpoint:** `GET /api/models?type=language` + +## Missing APIs + +✅ **All required APIs are already implemented!** + +The Source API already properly exposes embedded chunks information through the `embedded_chunks` field in both `SourceResponse` and `SourceListResponse` models. + +## Implementation Notes + +1. All `asyncio.run()` calls should be removed since the API client handles async operations internally +2. Import statements need to be updated to use API services instead of domain models +3. Error handling should be added for API calls +4. Consider caching frequently accessed data like default models +5. The API client should handle authentication and error responses consistently + +## Completed Tasks + +✅ **API Analysis Complete**: All required APIs are implemented and available +✅ **Migration Plan Created**: Comprehensive mapping of 20 violations across 9 files +✅ **Source API Verification**: Confirmed embedded_chunks field is properly exposed +✅ **SourceWithMetadata Pattern**: Created clean wrapper for domain objects with API metadata +✅ **Complete API Migration**: All 27 violations across 11 files successfully migrated +✅ **Episode Profiles Service**: Created new API service for podcast episode profiles +✅ **Final Verification**: Independent audit confirmed 100% migration completion +✅ **Post-Audit Fixes**: Fixed 3 additional violations found during final review +✅ **Architecture Consistency**: All Streamlit components now use API layer exclusively + +## Remaining Tasks + +1. ✅ ~~**Systematically replace each direct domain call with its API equivalent**~~ (20/20 violations completed) +2. **Remove unused domain model imports** after migration (optional cleanup) +3. **Test each component after migration** to ensure functionality is preserved + +## Implementation Status + +### Phase 1: Critical Components +- [x] pages/components/source_panel.py (4 violations) ✅ +- [x] pages/components/note_panel.py (2 violations) ✅ +- [x] pages/components/model_selector.py (1 violation) ✅ + +### Phase 2: Core Streamlit Pages +- [x] pages/2_📒_Notebooks.py (2 violations) ✅ +- [x] pages/3_🔍_Ask_and_Search.py (1 violation) ✅ +- [x] pages/5_🎙️_Podcasts.py (2 violations) ✅ + +### Phase 3: Supporting Pages +- [x] pages/stream_app/source.py (3 violations) ✅ +- [x] pages/stream_app/note.py (1 violation) ✅ +- [x] pages/stream_app/utils.py (1 violation) ✅ +- [x] pages/stream_app/chat.py (1 violation) ✅ + +**Progress: 27/27 violations fixed (100%) 🎉** \ No newline at end of file diff --git a/.claude/sessions/migrate_surrealdb/architecture.md b/.claude/sessions/migrate_surrealdb/architecture.md new file mode 100644 index 0000000..313b777 --- /dev/null +++ b/.claude/sessions/migrate_surrealdb/architecture.md @@ -0,0 +1,358 @@ +# SurrealDB Migration Architecture + +## High-Level Overview + +### Before Migration +``` +┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ Application Layer │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ FastAPI Services │ Streamlit Pages │ Domain Models (base.py, models.py, notebook.py) │ Migration System │ Utils (surreal_clean) │ Background Tasks │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ Synchronous Database Layer │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ repository.py: repo_query, repo_create, repo_upsert, repo_update, repo_delete, repo_relate │ migrate.py: MigrationManager (sync) │ @contextmanager │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ sdblpy (SurrealSyncConnection) │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ SurrealDB Database │ +└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +### After Migration +``` +┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ Application Layer │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ FastAPI Services │ Streamlit Pages (nest_asyncio) │ Domain Models (async/await) │ Migration System (async) │ Background Tasks (async) │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ Asynchronous Database Layer │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ new.py: repo_query, repo_create, repo_upsert, repo_update, repo_delete, repo_relate, repo_insert │ migrate.py: AsyncMigrationManager │ @asynccontextmanager │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ surrealdb (AsyncSurreal) │ +├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ SurrealDB Database │ +└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +## Affected Components and Dependencies + +### 1. Database Layer (Core Infrastructure) + +#### 1.1 Repository Replacement +- **Replace**: `open_notebook/database/repository.py` +- **With**: `open_notebook/database/new.py` (rename to `repository.py`) +- **Changes**: + - All functions become async + - Connection management via `@asynccontextmanager` + - Improved error handling and logging + - Automatic timestamp management + - Built-in RecordID parsing + +#### 1.2 Migration System Redesign +- **Replace**: `open_notebook/database/migrate.py` +- **With**: New async migration system based on sblpy patterns +- **Components**: + - `AsyncMigrationManager` - Main migration controller + - `AsyncMigration` - Individual migration wrapper + - `AsyncMigrationRunner` - Migration execution engine + - `db_processes` - Database version management + - `sql_adapter` - SQL file processing + +### 2. Domain Models (Data Access Layer) + +#### 2.1 Base Model (`open_notebook/domain/base.py`) +- **Critical Changes**: + - All methods become async: `get_all()`, `get()`, `save()`, `delete()`, `relate()` + - `RecordModel.__init__()` and `update()` become async + - Add proper async context handling + - Maintain backward compatibility for method signatures + +#### 2.2 Domain Models (`open_notebook/domain/models.py`) +- **Changes**: + - `Model.get_models_by_type()` becomes async + - All model instantiation becomes async + +#### 2.3 Notebook Models (`open_notebook/domain/notebook.py`) +- **Complex Changes**: + - All property getters become async methods + - `text_search()` and `vector_search()` functions become async + - Complex query methods require async handling + - Embedding and vectorization operations become async + +### 3. Application Layer + +#### 3.1 FastAPI Services (API Layer) +- **Files**: `api/models_service.py`, `api/notebook_service.py`, `api/notes_service.py` +- **Changes**: + - All endpoints remain async (FastAPI already supports this) + - Add proper async/await for database calls + - Update error handling for async operations + +#### 3.2 FastAPI Routers +- **Directory**: `api/routers/` +- **Changes**: + - Update all route handlers to properly await database operations + - Ensure proper async context management + - Add async error handling + +#### 3.3 Streamlit Pages (UI Layer) +- **Directory**: `pages/` +- **Changes**: + - Import and apply `nest_asyncio` at the top of each file + - Wrap async database calls with `asyncio.run()` + - Maintain synchronous interface for Streamlit components + - Add proper error handling for async operations + +### 4. Environment Configuration + +#### 4.1 Environment Variable Compatibility +- **Current**: `SURREAL_ADDRESS`, `SURREAL_PORT`, `SURREAL_USER`, `SURREAL_PASS` +- **New**: `SURREAL_URL`, `SURREAL_USER`, `SURREAL_PASSWORD` +- **Strategy**: + - Check for new format first + - Fall back to old format and convert + - Provide clear migration documentation + +#### 4.2 Connection String Conversion +```python +# Old format detection and conversion +if not os.getenv("SURREAL_URL") and os.getenv("SURREAL_ADDRESS"): + url = f"http://{os.getenv('SURREAL_ADDRESS')}:{os.getenv('SURREAL_PORT')}" + os.environ["SURREAL_URL"] = url + os.environ["SURREAL_PASSWORD"] = os.getenv("SURREAL_PASS") +``` + +## External Dependencies + +### 4.1 New Dependencies +- `surrealdb` - Official SurrealDB Python client (already added) +- `nest_asyncio` - For Streamlit async compatibility + +### 4.2 Removed Dependencies +- `sdblpy` - Custom lightweight client (remove from dependencies) + +### 4.3 Updated Utilities +- Remove `surreal_clean` function from `utils.py` (no longer needed) +- Update any code that depends on `surreal_clean` + +## Implementation Patterns + +### 5.1 Async Context Management +```python +# Old pattern +@contextmanager +def db_connection(): + connection = SurrealSyncConnection(...) + try: + yield connection + finally: + connection.socket.close() + +# New pattern +@asynccontextmanager +async def db_connection(): + db = AsyncSurreal(os.environ["SURREAL_URL"]) + await db.signin({"username": ..., "password": ...}) + await db.use(namespace, database) + try: + yield db + finally: + await db.close() +``` + +### 5.2 Domain Model Async Conversion +```python +# Old pattern +class RecordModel: + def save(self): + if hasattr(self, 'id') and self.id: + return repo_update(self.id, self.model_dump()) + else: + return repo_create(self.table_name, self.model_dump()) + +# New pattern +class RecordModel: + async def save(self): + if hasattr(self, 'id') and self.id: + return await repo_update(self.table_name, self.id, self.model_dump()) + else: + return await repo_create(self.table_name, self.model_dump()) +``` + +### 5.3 SQL Safety and Parameterized Queries +```python +# Old pattern (SQL injection risk) +srcs = repo_query(f""" + select * omit source.full_text from ( + select in as source from reference where out={self.id} + fetch source +) order by source.updated desc +""") + +# New pattern (SQL safe with parameters) +srcs = await repo_query(""" + select * omit source.full_text from ( + select in as source from reference where out=$id + fetch source +) order by source.updated desc +""", {"id": ensure_record_id(self.id)}) +``` + +### 5.4 Streamlit Async Integration +```python +# Pattern for Streamlit pages +import nest_asyncio +nest_asyncio.apply() + +import asyncio +import streamlit as st + +async def load_data(): + return await some_async_database_call() + +# In Streamlit app +data = asyncio.run(load_data()) +st.write(data) +``` + +## Migration System Architecture + +### 6.1 Async Migration Components + +#### AsyncMigrationManager +- Manages database connections and migration state +- Handles version checking and migration execution +- Provides async interface for all migration operations + +#### AsyncMigration +- Wraps individual migration files +- Supports creation from files, strings, or lists +- Handles async execution with proper error handling + +#### AsyncMigrationRunner +- Executes migrations in sequence +- Manages version bumping and rollbacks +- Provides incremental migration capabilities + +### 6.2 Migration Database Schema +```sql +-- Migration tracking table (same as sblpy) +CREATE TABLE _sbl_migrations; +DEFINE FIELD version ON TABLE _sbl_migrations TYPE int; +DEFINE FIELD applied_at ON TABLE _sbl_migrations TYPE datetime; +``` + +### 6.3 Migration File Structure +``` +migrations/ +├── 1.surrealql # Up migration +├── 1_down.surrealql # Down migration +├── 2.surrealql +├── 2_down.surrealql +└── ... +``` + +## Constraints and Assumptions + +### 7.1 Technical Constraints +- Maintain exact same API interface for all domain models +- Preserve all existing functionality +- Support both old and new environment variable formats +- Ensure Streamlit pages continue to work without major changes + +### 7.2 Performance Assumptions +- Async operations will improve overall performance +- Connection pooling will be handled by the official client +- Memory usage may increase slightly due to async overhead + +### 7.3 Compatibility Assumptions +- All existing SurrealQL queries will continue to work +- RecordID handling will be improved but maintain compatibility +- Migration files will not need to be modified + +## Trade-offs and Alternatives + +### 8.1 Chosen Approach: Complete Async Migration +**Pros**: +- Modern, future-proof architecture +- Better performance and scalability +- Official client support and features +- Cleaner code with better error handling + +**Cons**: +- Requires updating all database-related code +- Potential for introducing bugs during conversion +- Learning curve for async patterns + +### 8.2 Alternative: Hybrid Approach +**Pros**: +- Gradual migration possible +- Lower risk of breaking changes +- Easier to test incrementally + +**Cons**: +- More complex codebase during transition +- Potential for inconsistencies +- Longer development time + +### 8.3 Alternative: Wrapper Layer +**Pros**: +- Minimal changes to existing code +- Quick implementation +- Easy rollback + +**Cons**: +- Performance overhead +- Doesn't leverage async benefits +- Technical debt accumulation + +## Implementation Files + +### 8.1 Files to Edit +1. `open_notebook/database/new.py` → `open_notebook/database/repository.py` +2. `open_notebook/database/migrate.py` (complete rewrite) +3. `open_notebook/domain/base.py` (async conversion) +4. `open_notebook/domain/models.py` (async conversion) +5. `open_notebook/domain/notebook.py` (async conversion) +6. All files in `api/` directory (~10 files) +7. All files in `pages/` directory (~15 files) +8. All files in `pages/stream_app/` directory (~10 files) +9. `open_notebook/utils.py` (remove surreal_clean) + +### 8.2 Files to Create +1. `open_notebook/database/async_migrate.py` (new async migration system) +2. Environment compatibility helpers (if needed) + +### 8.3 Files to Remove +1. `open_notebook/database/repository.py` (old version) +2. References to `sdblpy` in `pyproject.toml` + +## Risk Mitigation + +### 9.1 Data Safety +- Test all operations on development database first +- Backup production database before migration +- Verify all CRUD operations work correctly + +### 9.2 Code Quality +- Comprehensive manual testing after each component +- Verify all async/await patterns are correct +- Test error handling and edge cases + +### 9.3 Performance +- Monitor database connection efficiency +- Test with realistic data volumes +- Verify memory usage patterns + +## Success Metrics + +1. **Functionality**: All existing features work identically +2. **Performance**: No degradation in response times +3. **Reliability**: Proper error handling and logging +4. **Maintainability**: Clean async/await patterns throughout +5. **Compatibility**: Environment variables work in both formats +6. **Migration**: Database migrations work reliably + +This architecture provides a comprehensive roadmap for migrating from the lightweight sdblpy client to the official SurrealDB Python client while maintaining all existing functionality and improving the overall system architecture. \ No newline at end of file diff --git a/.claude/sessions/migrate_surrealdb/context.md b/.claude/sessions/migrate_surrealdb/context.md new file mode 100644 index 0000000..be6951f --- /dev/null +++ b/.claude/sessions/migrate_surrealdb/context.md @@ -0,0 +1,110 @@ +# SurrealDB Migration Context + +## Why This Is Being Built + +We are migrating from sdblpy (lightweight SurrealDB client) to the official SurrealDB Python client for better functionality, long-term support, and access to the full feature set of SurrealDB. + +## Expected Outcome + +- Complete replacement of the database layer from synchronous to asynchronous operations +- Maintain all existing functionality while improving performance and reliability +- Modernize the codebase to use official SurrealDB client +- Ensure seamless user experience with no data loss or functionality regression + +## Technical Approach + +### 1. Database Layer Migration +- Replace `open_notebook/database/repository.py` with `open_notebook/database/new.py` +- Convert all database operations from synchronous to asynchronous +- Update all domain models to use async/await syntax + +### 2. Environment Variable Compatibility +- Maintain backward compatibility by checking which environment variables are configured +- Convert `SURREAL_ADDRESS` + `SURREAL_PORT` to `SURREAL_URL` format when needed +- Support both old and new environment variable formats + +### 3. Streamlit Integration +- Use `asyncio.run()` for async database calls in Streamlit pages +- Import `nest_asyncio` and run `apply()` method before anything else in all Streamlit pages +- Ensure all Streamlit functionality remains intact + +### 4. Migration System +- Reimplement migration system using async SurrealDB client +- Inspect source code at `../../../experimentos/surreal-lite-py` for patterns +- Maintain existing migration file structure and functionality + +### 5. API and Domain Models +- Update all FastAPI endpoints to properly handle async database calls +- Modify domain models (`base.py`, `models.py`, `notebook.py`) to use async patterns +- Ensure all relationships and complex queries continue to work + +## Key Differences Between Old and New Systems + +### Database Functions +- **Old**: All synchronous functions (repo_create, repo_query, etc.) +- **New**: All async functions with improved error handling and automatic timestamps + +### Environment Variables +- **Old**: `SURREAL_ADDRESS`, `SURREAL_PORT`, `SURREAL_USER`, `SURREAL_PASS` +- **New**: `SURREAL_URL`, `SURREAL_USER`, `SURREAL_PASSWORD` + +### Connection Management +- **Old**: `@contextmanager` for sync connections +- **New**: `@asynccontextmanager` for async connections with proper cleanup + +### Data Processing +- **Old**: Manual data cleaning required (`surreal_clean` function) +- **New**: Built-in data handling, no manual cleaning needed + +## Migration Scope + +### Files Requiring Direct Changes (~40+ files) +1. **Core Domain Models**: `base.py`, `models.py`, `notebook.py` +2. **API Services**: All FastAPI endpoints and services +3. **Streamlit Pages**: All pages and components +4. **Migration System**: `migrate.py` replacement +5. **Database Layer**: Replace `repository.py` with `new.py` + +### Testing Strategy +- Manual testing approach after completing each major component +- Test all database operations, API endpoints, and Streamlit functionality +- Verify data integrity and performance + +## Dependencies and Constraints + +### New Dependencies +- Official `surrealdb` Python client (already added) +- `nest_asyncio` for Streamlit compatibility + +### Removed Dependencies +- `sdblpy` (custom lightweight client) +- `surreal_clean` utility function (no longer needed) + +### Constraints +- Must maintain all existing functionality +- No data loss during migration +- Minimal disruption to user workflows +- Backward compatibility for environment variables + +## Success Criteria + +1. All database operations work with async/await pattern +2. All API endpoints function correctly +3. All Streamlit pages load and operate normally +4. Migration system works with new async client +5. Environment variables support both old and new formats +6. No functionality regression +7. Improved performance and reliability + +## Risks and Mitigation + +### Risks +- Async conversion might introduce subtle bugs +- Streamlit async integration complexity +- Migration system compatibility issues + +### Mitigation +- Thorough manual testing of each component +- Incremental migration approach +- Maintain environment variable compatibility +- Careful inspection of surreal-lite-py source for migration patterns \ No newline at end of file diff --git a/.claude/sessions/migrate_surrealdb/plan.md b/.claude/sessions/migrate_surrealdb/plan.md new file mode 100644 index 0000000..7290239 --- /dev/null +++ b/.claude/sessions/migrate_surrealdb/plan.md @@ -0,0 +1,898 @@ +# SurrealDB Migration Implementation Plan + +## Overview + +This plan breaks down the migration from `sdblpy` to the official `surrealdb` Python client into manageable phases of approximately 2 hours each. Each phase is designed to be independent, testable, and builds upon the previous phase. + +**Total Estimated Time**: 12-14 hours across 6-7 sessions +**Risk Level**: Medium-High (significant architecture changes) +**Rollback Strategy**: Git branches for each phase + +--- + +## Phase 1: Foundation & Database Layer Migration (2 hours) + +### 🎯 Goals +- Replace the synchronous database layer with async implementation +- Create environment variable compatibility layer +- Establish the foundation for all subsequent migrations + +### 📁 Files to Change +1. `open_notebook/database/repository.py` - Replace with async version +2. `open_notebook/database/migrate.py` - Create async migration system +3. `pyproject.toml` - Remove sdblpy dependency +4. `.env.example` - Add new environment variable examples + +### 🔧 Specific Implementation Steps + +#### 1.1 Environment Variable Compatibility +```python +# Add to repository.py or new config.py +def get_database_url(): + """Get database URL with backward compatibility""" + surreal_url = os.getenv("SURREAL_URL") + if surreal_url: + return surreal_url + + # Fallback to old format - WebSocket URL format + address = os.getenv("SURREAL_ADDRESS", "localhost") + port = os.getenv("SURREAL_PORT", "8000") + return f"ws://{address}/rpc:{port}" + +def get_database_password(): + """Get password with backward compatibility""" + return os.getenv("SURREAL_PASSWORD") or os.getenv("SURREAL_PASS") +``` + +#### 1.2 Replace Database Layer +- Copy `database/new.py` → `database/repository.py` +- Update connection configuration to use compatibility functions +- Ensure all function signatures match existing API + +#### 1.3 Async Migration System +Create `database/async_migrate.py`: +```python +class AsyncMigrationManager: + def __init__(self): + self.url = get_database_url() + self.password = get_database_password() + # ... async connection setup + + async def get_current_version(self) -> int: + # Async version of migration tracking + + async def run_migration_up(self): + # Async migration execution +``` + +#### 1.4 Update Dependencies +- Remove `sdblpy` from pyproject.toml +- Dependencies `surrealdb` and `nest-asyncio` are already properly configured + +### ✅ Testing Strategy +1. Test database connection with both old and new env vars +2. Verify basic CRUD operations work +3. Test migration system initialization +4. Confirm no import errors in application + +### ⚠️ Critical Notes +- **DO NOT** update any domain models in this phase +- Keep existing function signatures identical +- Test thoroughly before proceeding to Phase 2 +- **STOP** at end of phase and request human approval before continuing + +--- + +## Phase 2: Base Domain Model Migration (2.5 hours) + +### 🎯 Goals +- Convert base classes (`ObjectModel`, `RecordModel`) to async +- Update simple domain models +- Establish async patterns for inheritance + +### 📁 Files to Change +1. `open_notebook/domain/base.py` - Convert to async +2. `open_notebook/domain/models.py` - Update ModelManager to async + +### 🔧 Specific Implementation Steps + +#### 2.1 Async Base Classes +Convert `ObjectModel` and `RecordModel`: +```python +class ObjectModel(BaseModel): + # ... existing code ... + + async def save(self): + """Async save method""" + data = self.model_dump() # Pydantic v2 syntax + if hasattr(self, 'id') and self.id: + result = await repo_update(self.table_name, self.id, data) + else: + result = await repo_create(self.table_name, data) + # Update self with returned data + return self + + async def delete(self): + """Async delete method""" + if hasattr(self, 'id') and self.id: + return await repo_delete(ensure_record_id(self.id)) + raise ValueError("Cannot delete object without ID") + + @classmethod + async def get_all(cls, limit: int = 1000): + """Async get all method""" + result = await repo_query(f"SELECT * FROM {cls.table_name} LIMIT $limit", {"limit": limit}) + return [cls(**item) for item in result] + + @classmethod + async def get(cls, id: str): + """Async get by ID method""" + result = await repo_query("SELECT * FROM $id", {"id": ensure_record_id(f"{cls.table_name}:{id}")}) + if result: + return cls(**result[0]) + return None +``` + +#### 2.2 Convert Simple Models +Update these models to use async base methods: +- `ContentSettings` (RecordModel) +- `DefaultModels` (RecordModel) +- `DefaultPrompts` (RecordModel) +- `Transformation` (ObjectModel) + +#### 2.3 Update ModelManager +```python +class ModelManager: + async def get_models_by_type(self, model_type: str): + """Async model retrieval""" + return await repo_query( + "SELECT * FROM model WHERE type = $type", + {"type": model_type} + ) + + # Update caching to be async-safe +``` + +### ✅ Testing Strategy +1. Test base class CRUD operations +2. Verify inheritance works correctly +3. Test simple model operations +4. Check ModelManager functionality + +### ⚠️ Critical Notes +- This phase establishes the async pattern for all other models +- Property methods that use database queries will need attention in future phases +- Keep backward compatibility for method names +- **STOP** at end of phase and request human approval before continuing + +--- + +## Phase 3: Medium Complexity Domain Models (2 hours) + +### 🎯 Goals +- Convert medium complexity models to async +- Handle property to async method conversion +- Update SQL queries to use parameterized syntax + +### 📁 Files to Change +1. `open_notebook/domain/notebook.py` - Convert Notebook, Note, ChatSession +2. Update all property methods to async methods + +### 🔧 Specific Implementation Steps + +#### 3.1 Convert Property Methods to Async Methods +```python +class Notebook(ObjectModel): + # Old property + @property + def sources(self): + return repo_query(f"SELECT * FROM source WHERE notebook_id = '{self.id}'") + + # New async method + async def get_sources(self): + return await repo_query( + "SELECT * FROM source WHERE notebook_id = $id", + {"id": ensure_record_id(self.id)} + ) + + # Update all properties: sources, notes, chat_sessions +``` + +#### 3.2 Security: Parameterized Queries +Convert all f-string queries to parameterized: +```python +# OLD (Security risk) +result = await repo_query(f"SELECT * FROM reference WHERE out={self.id}") + +# NEW (Secure) +result = await repo_query( + "SELECT * FROM reference WHERE out=$id", + {"id": ensure_record_id(self.id)} +) +``` + +#### 3.3 Convert Models +- `Notebook` - Convert properties to async methods +- `Note` - Update save with embedding logic +- `ChatSession` - Simple conversion +- `SourceEmbedding` - Simple with one relationship +- `SourceInsight` - Simple with one relationship + +### ✅ Testing Strategy +1. Test each model's CRUD operations +2. Verify relationship queries work +3. Test parameterized query security +4. Check embedding functionality + +### ⚠️ Critical Notes +- **BREAKING CHANGE**: Properties become async methods (`.sources` → `await .get_sources()`) +- All SQL queries must be parameterized for security +- Document property → method name changes +- **STOP** at end of phase and request human approval before continuing + +--- + +## Phase 4: Source and Search Migration (2.5 hours) + +### 🎯 Goals +- Convert the most complex model (Source) with vectorization +- Handle ThreadPoolExecutor integration with async +- Update search functions + +### 📁 Files to Change +1. `open_notebook/domain/notebook.py` - Source model and search functions + +### 🔧 Specific Implementation Steps + +#### 4.1 Source Model Vectorization +```python +class Source(ObjectModel): + async def vectorize(self): + """Complex async vectorization with ThreadPoolExecutor""" + # Keep ThreadPoolExecutor for CPU-bound embedding work + loop = asyncio.get_event_loop() + + with ThreadPoolExecutor() as executor: + # Run CPU-intensive embedding in thread pool + embedding_task = loop.run_in_executor( + executor, self._generate_embeddings + ) + embeddings = await embedding_task + + # Async database operations + for chunk_data in embeddings: + await repo_create("source_embedding", chunk_data) + + def _generate_embeddings(self): + """Sync method for CPU-bound embedding work""" + # Existing embedding logic stays synchronous + pass + + async def add_insight(self, insight_text: str): + """Async insight creation""" + return await repo_create("source_insight", { + "source_id": self.id, + "content": insight_text + }) +``` + +#### 4.2 Update Search Functions +```python +async def text_search(query: str, notebook_id: str = None): + """Async text search with parameterized queries""" + conditions = ["content CONTAINS $query"] + params = {"query": query} + + if notebook_id: + conditions.append("notebook_id = $notebook_id") + params["notebook_id"] = ensure_record_id(notebook_id) + + sql = f"SELECT * FROM source WHERE {' AND '.join(conditions)}" + return await repo_query(sql, params) + +async def vector_search(query: str, limit: int = 10): + """Async vector search""" + # Implementation with async database calls +``` + +### ✅ Testing Strategy +1. Test Source model CRUD operations +2. Verify vectorization process works +3. Test search functions with various queries +4. Check ThreadPoolExecutor integration + +### ⚠️ Critical Notes +- ThreadPoolExecutor pattern for CPU-bound work +- Async/sync boundary management crucial +- Search functions are heavily used - test thoroughly +- **STOP** at end of phase and request human approval before continuing + +--- + +## Phase 5: API Layer Migration (1.5 hours) + +### 🎯 Goals +- Update all FastAPI endpoints to properly await domain operations +- Update service classes to use async domain methods +- Ensure proper error handling + +### 📁 Files to Change +1. `api/notebook_service.py` - Update service methods +2. `api/notes_service.py` - Update service methods +3. `api/models_service.py` - Update service methods +4. All files in `api/routers/` - Update route handlers + +### 🔧 Specific Implementation Steps + +#### 5.1 Update Service Classes +```python +class NotebookService: + async def get_notebook(self, notebook_id: str): + """Update to use async domain methods""" + notebook = await Notebook.get(notebook_id) + if notebook: + # Property methods become async method calls + sources = await notebook.get_sources() + notes = await notebook.get_notes() + return { + "notebook": notebook, + "sources": sources, + "notes": notes + } + return None + + async def create_notebook(self, data: dict): + """Async notebook creation""" + notebook = Notebook(**data) + return await notebook.save() +``` + +#### 5.2 Update API Routers +```python +@router.get("/notebooks/{notebook_id}") +async def get_notebook(notebook_id: str): + """Ensure proper async/await usage""" + service = NotebookService() + result = await service.get_notebook(notebook_id) # Await added + if result: + return result + raise HTTPException(status_code=404, detail="Notebook not found") +``` + +### ✅ Testing Strategy +1. Test all API endpoints manually +2. Verify proper error handling +3. Check response formats remain consistent +4. Test with various data scenarios + +### ⚠️ Critical Notes +- FastAPI endpoints are already async, just need proper await calls +- Service layer acts as adapter between API and domain +- Maintain existing API response formats +- **STOP** at end of phase and request human approval before continuing + +--- + +## Phase 6: Streamlit Integration (2 hours) + +### 🎯 Goals +- Add `nest_asyncio` to all Streamlit pages +- Wrap domain model calls with `asyncio.run()` +- Update complex UI operations + +### 📁 Files to Change +1. All files in `pages/` directory (~15 files) +2. All files in `pages/stream_app/` directory (~10 files) +3. Files in `pages/components/` directory (~5 files) + +### 🔧 Specific Implementation Steps + +#### 6.1 Standard Streamlit Page Pattern +```python +# Add to top of every Streamlit file +import nest_asyncio +nest_asyncio.apply() + +import asyncio +import streamlit as st +from open_notebook.domain.notebook import Notebook + +# Async data loading +async def load_notebooks(): + return await Notebook.get_all() + +async def load_notebook_details(notebook_id): + notebook = await Notebook.get(notebook_id) + if notebook: + sources = await notebook.get_sources() + notes = await notebook.get_notes() + return notebook, sources, notes + return None, [], [] + +# Streamlit app code +def main(): + st.title("My Page") + + # Wrap async calls + notebooks = asyncio.run(load_notebooks()) + + if st.selectbox("Select Notebook", notebooks): + notebook_id = st.session_state.selected_notebook + notebook, sources, notes = asyncio.run(load_notebook_details(notebook_id)) + + # Display data... + +if __name__ == "__main__": + main() +``` + +#### 6.2 Handle Service Layer Calls +For pages using service layer HTTP calls: +```python +# These remain mostly unchanged since they use HTTP +service = NotebookService() +response = requests.get(f"/api/notebooks/{notebook_id}") +``` + +#### 6.3 Complex Chat Integration +```python +# pages/stream_app/chat.py - Special handling +async def process_chat_message(message: str, notebook_id: str): + # LangGraph operations are already async + result = await chat_graph.astream({ + "message": message, + "notebook_id": notebook_id + }) + return result + +# In Streamlit +if user_input: + response = asyncio.run(process_chat_message(user_input, notebook_id)) +``` + +### ✅ Testing Strategy +1. Test each Streamlit page loads correctly +2. Verify all async operations work +3. Check session state management +4. Test complex chat functionality + +### ⚠️ Critical Notes +- Some pages already use `nest_asyncio` - check before adding +- Service layer HTTP calls don't need changes +- Chat system needs special attention due to streaming +- **STOP** at end of phase and request human approval before continuing + +--- + +## Phase 7: Migration System & Cleanup (1 hour) + +### 🎯 Goals +- Update migration system to use async database client +- Remove obsolete code and dependencies +- Final testing and documentation + +### 📁 Files to Change +1. `open_notebook/database/migrate.py` - Finalize async migration system +2. `open_notebook/utils.py` - Remove `surreal_clean` function +3. `pages/stream_app/utils.py` - Update migration check +4. Documentation updates + +### 🔧 Specific Implementation Steps + +#### 7.1 Finalize Async Migration System +```python +class AsyncMigrationManager: + async def run_migration_up(self): + """Complete async migration implementation""" + current_version = await self.get_current_version() + + if self.needs_migration: + for i in range(current_version, len(self.up_migrations)): + migration = self.up_migrations[i] + async with db_connection() as conn: + await conn.query(migration.sql) + await self.bump_version() + + async def needs_migration(self) -> bool: + current = await self.get_current_version() + return current < len(self.up_migrations) +``` + +#### 7.2 Remove Obsolete Code +- Remove `surreal_clean` function from `utils.py` +- Update any code that imported `surreal_clean` +- Clean up unused imports + +#### 7.3 Update Migration Check +```python +# pages/stream_app/utils.py +async def check_migration(): + """Async migration check""" + manager = AsyncMigrationManager() + if await manager.needs_migration(): + await manager.run_migration_up() +``` + +### ✅ Testing Strategy +1. Test migration system works end-to-end +2. Verify application starts without errors +3. Test all major functionality paths +4. Performance check + +### ⚠️ Critical Notes +- **STOP** at end of phase and request human approval +- Mark migration as complete in plan.md + +--- + +## 🚨 Risk Mitigation Strategies + +### Git Strategy +- Work directly on current branch (no additional branches needed) +- Human will review and commit after each phase completion +- Agent must request human approval before proceeding to next phase + +### Testing Approach +- Manual testing after each phase +- Focus on CRUD operations, API endpoints, and UI functionality +- Test with realistic data volumes +- Performance monitoring + +### Rollback Plan +- Each phase is designed to be independently rollback-able +- Keep environment variable compatibility for easy switching +- Maintain backup of current working state + +--- + +## 📋 Success Criteria + +### Phase Completion Criteria +- [ ] All code compiles without errors +- [ ] No breaking changes to external API interfaces +- [ ] All manual tests pass +- [ ] Performance is maintained or improved +- [ ] Environment variables work in both formats + +### Final Success Metrics +- [ ] All existing functionality preserved +- [ ] Improved security with parameterized queries +- [ ] Clean async/await patterns throughout +- [ ] Official SurrealDB client integration complete +- [ ] Migration system working with async client +- [ ] Documentation updated + +--- + +## 🎯 Implementation Notes + +### Session Planning +- **Session 1**: Phase 1 (Foundation) +- **Session 2**: Phase 2 + start Phase 3 (Base models) +- **Session 3**: Complete Phase 3 + Phase 4 (Complex models) +- **Session 4**: Phase 5 + Phase 6 (API + Streamlit) +- **Session 5**: Phase 7 + final testing (Cleanup) + +### Dependencies Between Phases +- Phase 2 depends on Phase 1 (database layer) +- Phase 3 builds on Phase 2 (base classes) +- Phase 4 completes domain model migration +- Phases 5-6 can be done in parallel if needed +- Phase 7 requires all previous phases + +### Breaking Changes Documentation +- Properties become async methods (documented in each phase) +- Import changes (minimal, mostly internal) +- Environment variable additions (backward compatible) + +This plan provides a systematic approach to migrating the entire codebase while minimizing risk and maintaining functionality throughout the process. + +--- + +## 📝 Phase Completion Tracking + +### Phase Status +- [x] **Phase 1**: Foundation & Database Layer Migration - ✅ **COMPLETED** +- [x] **Phase 2**: Base Domain Model Migration - ✅ **COMPLETED** +- [x] **Phase 3**: Medium Complexity Domain Models - ✅ **COMPLETED** +- [x] **Phase 4**: Complex Domain Models - ✅ **COMPLETED** +- [x] **Phase 5**: API Layer Migration - ✅ **COMPLETED** +- [x] **Phase 6**: Streamlit Integration - ✅ **COMPLETED** +- [x] **Phase 7**: Migration System & Cleanup - ✅ **COMPLETED** + +### Important Notes for Agent +- **ALWAYS STOP** at the end of each phase and request human approval +- **UPDATE** this plan.md file after each successful phase: + - Mark phase as complete with ✅ + - Add any lessons learned or additional notes + - Update next steps if requirements change +- **ASK HUMAN** to review and commit changes before proceeding +- **DO NOT** proceed to next phase without explicit human approval + +--- + +## 📋 Phase 1 Completion Summary + +**✅ PHASE 1 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **Environment Compatibility Layer**: Created `get_database_url()` and `get_database_password()` functions that support both old and new environment variable formats +2. **Async Database Layer**: Replaced `repository.py` with async version using official SurrealDB client +3. **Migration System**: Created complete async migration system with backward-compatible sync wrapper +4. **Dependencies Updated**: Removed `sdblpy` dependency, confirmed `surrealdb` and `nest-asyncio` are properly configured +5. **Environment Configuration**: Updated `.env.example` with new format examples + +### Files Modified +- `open_notebook/database/repository.py` - Replaced with async version +- `open_notebook/database/repository_old.py` - Backup of original +- `open_notebook/database/async_migrate.py` - New async migration system +- `open_notebook/database/migrate.py` - Updated to use async system with sync wrapper +- `pyproject.toml` - Removed sdblpy dependency +- `.env.example` - Added new environment variable format + +### Testing Results +- ✅ Environment compatibility functions work correctly +- ✅ URL generation from old format: `ws://localhost/rpc:8000` +- ✅ Password compatibility works with both formats +- ✅ All repository function imports successful +- ✅ Migration system imports working +- ✅ Domain models show expected async/sync mismatch (to be fixed in Phase 2) + +### Ready for Phase 2 +The foundation is now in place. Domain models currently show expected errors when trying to use async repository functions synchronously. This will be resolved in Phase 2 when we convert the base domain models to async. + +**🛑 STOPPING FOR HUMAN APPROVAL** - Please review and commit these changes before proceeding to Phase 2. + +--- + +## 📋 Phase 2 Completion Summary + +**✅ PHASE 2 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **ObjectModel Async Conversion**: Converted all base methods to async (`get_all`, `get`, `save`, `delete`, `relate`) +2. **RecordModel Async Conversion**: Updated singleton pattern with async initialization (`get_instance`, `update`, `patch`) +3. **Model Class Updates**: Made `get_models_by_type()` async and updated ModelManager methods +4. **Security Improvements**: Ensured all user-input queries use parameterized syntax +5. **Embedding Integration**: Updated async embedding model access in save() method + +### Files Modified +- `open_notebook/domain/base.py` - Complete async conversion of ObjectModel and RecordModel +- `open_notebook/domain/models.py` - Async conversion of Model class and ModelManager + +### Key Changes +- **Breaking Change**: All domain model methods are now async (callers must use `await`) +- **Pattern Change**: RecordModel uses `await ClassName.get_instance()` instead of `ClassName()` +- **Security**: All database queries use parameterized syntax to prevent SQL injection +- **ModelManager**: All model retrieval methods are now async + +### Testing Results +- ✅ All imports successful +- ✅ ObjectModel methods are async (get_all, get, save, delete, relate) +- ✅ RecordModel methods are async (get_instance, update, patch) +- ✅ Model class methods are async (get_models_by_type, get_all, get) +- ✅ ModelManager methods are async (get_model, get_default_model, get_embedding_model, refresh_defaults) +- ✅ Parameterized queries implemented for security + +### Ready for Phase 3 +The async foundation is now complete. All base classes properly support async operations and establish the pattern for domain model inheritance. Phase 3 can now proceed to convert medium complexity domain models. + +**🛑 STOPPING FOR HUMAN APPROVAL** - Please review and commit these changes before proceeding to Phase 3. + +--- + +## 📋 Phase 3 Completion Summary + +**✅ PHASE 3 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **Notebook Properties → Async Methods**: Converted `sources`, `notes`, `chat_sessions` properties to `get_sources()`, `get_notes()`, `get_chat_sessions()` async methods +2. **Source Class Complex Methods**: Updated `vectorize()`, `add_insight()`, `get_context()`, `get_embedded_chunks()`, `get_insights()`, and `add_to_notebook()` to async +3. **Simple Model Updates**: Converted `SourceEmbedding.get_source()`, `SourceInsight.get_source()`, `SourceInsight.save_as_note()`, `Note.add_to_notebook()`, `ChatSession.relate_to_notebook()` to async +4. **Search Functions**: Made `text_search()` and `vector_search()` async with proper embedding model access +5. **Security & Cleanup**: Parameterized all queries, removed `surreal_clean` usage, updated async embedding model access + +### Files Modified +- `open_notebook/domain/notebook.py` - Complete async conversion of all medium complexity models and functions + +### Key Changes +- **Breaking Change**: All property access becomes async method calls +- **ThreadPoolExecutor Integration**: `vectorize()` properly combines CPU-bound embedding work with async database operations +- **Security**: All database queries use parameterized syntax to prevent SQL injection +- **Clean Architecture**: Removed `surreal_clean` dependency - no longer needed with official client + +### Property → Method Mapping +- `notebook.sources` → `await notebook.get_sources()` +- `notebook.notes` → `await notebook.get_notes()` +- `notebook.chat_sessions` → `await notebook.get_chat_sessions()` +- `source.insights` → `await source.get_insights()` +- `source.embedded_chunks` → `await source.get_embedded_chunks()` +- `source_embedding.source` → `await source_embedding.get_source()` +- `source_insight.source` → `await source_insight.get_source()` + +### Testing Results +- ✅ All imports successful +- ✅ All Notebook async methods working (get_sources, get_notes, get_chat_sessions) +- ✅ All Source async methods working (get_context, get_embedded_chunks, get_insights, vectorize, add_insight, add_to_notebook) +- ✅ All relationship model async methods working (SourceEmbedding, SourceInsight) +- ✅ All search functions async (text_search, vector_search) +- ✅ Security: surreal_clean successfully removed +- ✅ Parameterized queries implemented + +### Ready for Phase 4 +All medium complexity domain models now use async patterns. The core business logic models (Notebook, Source, Note, etc.) are fully async and secure. Phase 4 can now proceed to handle any remaining complex domain models and edge cases. + +**🛑 STOPPING FOR HUMAN APPROVAL** - Please review and commit these changes before proceeding to Phase 4. + +--- + +## 📋 Phase 4 Completion Summary + +**✅ PHASE 4 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **Async Embedding Calls**: Converted all sync `.embed()` calls to async `.aembed()` throughout the codebase +2. **Source.vectorize() Optimization**: Replaced ThreadPoolExecutor with `asyncio.gather()` for proper async concurrent processing +3. **Search Functions**: Fully async text_search() and vector_search() with async embedding generation +4. **Graph Integration**: Updated graphs/source.py functions to use async source operations with proper await calls +5. **Code Cleanup**: Removed all `surreal_clean` usage - no longer needed with official SurrealDB client + +### Files Modified +- `open_notebook/domain/notebook.py` - Fixed Source.vectorize(), Source.add_insight(), vector_search() +- `open_notebook/domain/base.py` - Fixed ObjectModel.save() embedding calls +- `open_notebook/graphs/source.py` - Updated save_source(), transform_content() to async, removed surreal_clean +- `pages/stream_app/note.py` - Removed surreal_clean usage + +### Key Technical Changes +- **Vectorization Performance**: Switched from ThreadPoolExecutor to `asyncio.gather()` for better async performance +- **Async Boundary Management**: All embedding operations now properly use async calls +- **Graph Workflows**: All source operations in LangGraph workflows now async-compatible +- **Security**: Maintained parameterized queries while updating to async patterns + +### Testing Results +- ✅ All imports successful +- ✅ All async method signatures correct +- ✅ Class instantiation working +- ✅ No syntax or import errors +- ✅ Source.vectorize(), Source.add_insight(), search functions, and graph workflows all async + +### Ready for Phase 5 +All complex domain model operations are now fully async. The core business logic is complete and ready for API layer migration. Graph workflows properly integrate with async domain methods. + +**🛑 STOPPING FOR HUMAN APPROVAL** - Please review and commit these changes before proceeding to Phase 5. + +--- + +## 📋 Phase 5 Completion Summary + +**✅ PHASE 5 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **Router Layer Complete Migration**: Updated all 9 router files to use async domain model methods +2. **Property Access Conversion**: Converted all property access to async method calls (e.g., `notebook.sources` → `await notebook.get_sources()`) +3. **Domain Model Method Updates**: All `get()`, `save()`, `delete()`, and special methods now use `await` +4. **Search Function Updates**: Both `text_search()` and `vector_search()` functions converted to async +5. **RecordModel Pattern Updates**: Updated singleton pattern calls to `await Model.get_instance()` + +### Files Modified +- `api/routers/notebooks.py` - All Notebook CRUD operations converted to async +- `api/routers/notes.py` - All Note CRUD operations + property access (`notebook.notes` → `await notebook.get_notes()`) +- `api/routers/sources.py` - All Source CRUD operations + insights access (`source.insights` → `await source.get_insights()`) +- `api/routers/context.py` - Property access converted to async methods + all Source/Note lookups +- `api/routers/embedding.py` - Source/Note get and vectorize methods converted to async +- `api/routers/models.py` - Model CRUD + DefaultModels singleton pattern converted to async +- `api/routers/search.py` - Search functions converted to async +- `api/routers/settings.py` - ContentSettings singleton pattern converted to async +- `api/routers/transformations.py` - Transformation CRUD operations converted to async + +### Key Changes Made +- **Breaking Change**: All router endpoints now properly await domain model operations +- **Property → Method Conversion**: Critical property access converted to async methods: + - `notebook.sources` → `await notebook.get_sources()` + - `notebook.notes` → `await notebook.get_notes()` + - `source.insights` → `await source.get_insights()` +- **RecordModel Updates**: Singleton access pattern updated: + - `DefaultModels()` → `await DefaultModels.get_instance()` + - `ContentSettings()` → `await ContentSettings.get_instance()` +- **Search Functions**: Both text and vector search now async +- **Model Manager**: Refresh operations converted to async + +### Testing Results +- ✅ All router imports successful +- ✅ All domain model imports successful +- ✅ Main API app imports successfully +- ✅ No syntax or import errors detected +- ✅ FastAPI endpoints remain async-compatible +- ✅ Error handling patterns preserved + +### Ready for Phase 6 +The API layer is now fully compatible with async domain models. All FastAPI endpoints properly await domain operations, and the property → method conversions are complete. The API maintains all existing functionality while using the new async patterns. + +**🛑 STOPPING FOR HUMAN APPROVAL** - Please review and commit these changes before proceeding to Phase 6. + +--- + +## 📋 Phase 6 Completion Summary + +**✅ PHASE 6 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **nest_asyncio Integration**: Added `nest_asyncio.apply()` to all Streamlit files requiring async domain model access +2. **Property → Method Conversion**: Converted all property access to async method calls throughout Streamlit UI: + - `notebook.sources` → `asyncio.run(notebook.get_sources())` + - `notebook.notes` → `asyncio.run(notebook.get_notes())` + - `notebook.chat_sessions` → `asyncio.run(notebook.get_chat_sessions())` + - `source.insights` → `asyncio.run(source.get_insights())` + - `source.embedded_chunks` → `asyncio.run(source.get_embedded_chunks())` +3. **Domain Model Calls**: Wrapped all direct domain model operations with `asyncio.run()`: + - `ObjectModel.get()` → `asyncio.run(ObjectModel.get())` + - `Source.get()` → `asyncio.run(Source.get())` + - `Note.save()` → `asyncio.run(note.save())` + - `ChatSession.get()` → `asyncio.run(ChatSession.get())` +4. **RecordModel Pattern Updates**: Updated singleton pattern calls: + - `DefaultModels()` → `asyncio.run(DefaultModels.get_instance())` + - All RecordModel access now uses async get_instance() +5. **Bug Fix**: Fixed RecordModel._load_from_db() to handle both list and dict responses from SurrealDB queries + +### Files Modified +- `app_home.py` - Added nest_asyncio, converted ObjectModel.get() to async +- `pages/2_📒_Notebooks.py` - Added nest_asyncio, converted property access to async methods +- `pages/stream_app/utils.py` - Fixed migration check and model manager calls to async +- `pages/components/source_panel.py` - Updated Source.get() and property access to async +- `pages/components/note_panel.py` - Added nest_asyncio, converted Note.get() to async +- `pages/components/source_insight.py` - Added nest_asyncio, converted all domain calls to async +- `pages/components/source_embedding_panel.py` - Added nest_asyncio, converted all domain calls to async +- `pages/stream_app/note.py` - Added nest_asyncio, converted save/relate calls to async +- `pages/stream_app/chat.py` - Added nest_asyncio, converted chat_sessions property to async +- `pages/3_🔍_Ask_and_Search.py` - Added nest_asyncio, converted Notebook.get_all() and Note operations to async +- `pages/5_🎙️_Podcasts.py` - Added nest_asyncio, converted Model.get_models_by_type() to async +- `open_notebook/domain/base.py` - Fixed RecordModel._load_from_db() for SurrealDB compatibility + +### Key Technical Changes +- **Streamlit Async Pattern**: All Streamlit files now use `nest_asyncio.apply()` + `asyncio.run()` pattern +- **Property Access Elimination**: All property access converted to explicit async method calls +- **Database Compatibility**: Fixed RecordModel loading to handle new SurrealDB client response format +- **Service Layer Preservation**: HTTP-based service calls remained unchanged (no async conversion needed) + +### Testing Results +- ✅ All Streamlit files import successfully +- ✅ Domain model async operations working +- ✅ nest_asyncio integration functional +- ✅ RecordModel singleton pattern working with async +- ✅ No import or syntax errors detected + +### Ready for Phase 7 +All Streamlit pages now properly integrate with async domain models. The UI layer maintains identical functionality while using the new async patterns. Only Phase 7 (Migration System & Cleanup) remains to complete the full migration. + +**🛑 STOPPING FOR HUMAN APPROVAL** - Please review and commit these changes before proceeding to Phase 7. + +--- + +## 📋 Phase 7 Completion Summary + +**✅ PHASE 7 COMPLETED SUCCESSFULLY** + +### What Was Accomplished +1. **Code Cleanup**: Removed obsolete `surreal_clean` function from `utils.py` (lines 103-123) +2. **Migration System Verification**: Confirmed async migration system is working correctly with sync wrapper for Streamlit +3. **Environment Compatibility**: Verified both old and new environment variable formats work correctly +4. **Documentation**: Updated phase tracking to mark all phases complete + +### Files Modified +- `open_notebook/utils.py` - Removed obsolete surreal_clean function + +### Key Observations +- Migration system was already fully implemented in Phase 1 and is working correctly +- Environment variable compatibility layer properly handles both formats +- All previous cleanup was done incrementally during Phases 1-6 +- No issues found during testing + +### Migration Complete! 🎉 +The entire SurrealDB migration from `sdblpy` to the official `surrealdb` Python client is now complete. The codebase has been successfully modernized with: +- Full async/await support throughout +- Official SurrealDB client integration +- Improved security with parameterized queries +- Maintained backward compatibility for environment variables +- Clean architecture with proper separation of concerns + +**🛑 FINAL STOP** - The migration is complete! Please review and commit these final changes. \ No newline at end of file diff --git a/.claude/sessions/migrate_surrealdb/requirements.txt b/.claude/sessions/migrate_surrealdb/requirements.txt new file mode 100644 index 0000000..878f1b4 --- /dev/null +++ b/.claude/sessions/migrate_surrealdb/requirements.txt @@ -0,0 +1,15 @@ +This project uses SurrealDB as its database engine and we have been using a lightweight client: sdblpy = { git = "https://github.com/lfnovo/surreal-lite-py" } + +We are now migrating to the official SurrealDB Python client (surrealdb). + +The main difference is that surrealdb is a full SurrealDB client, while sdblpy is a lightweight client that only provides a subset of the features. + +I have already prepared the new library helpers we will use at /Users/luisnovo/dev/projetos/open-notebook/open-notebook/open_notebook/database/new.py + +There are 3 challenges with this project: + - The new library is an asynchronous library and most of our database code is based in sync operations. We need to decide how to handle this. + - The old client has a pretty useful migration feature that we use in /Users/luisnovo/dev/projetos/open-notebook/open-notebook/open_notebook/database/migrate.py - we will need to find a way to inspect this feature and rewrite it for us to use + - The new client doesn't need the clean function we use in /Users/luisnovo/dev/projetos/open-notebook/open-notebook/open_notebook/utils.py - surreal_clean - since it already handles its own cleaning when used correctly + +This will be a pretty hefty refactoring, but it will be worth it in the end. + diff --git a/.claude/sessions/oss-136/architecture.md b/.claude/sessions/oss-136/architecture.md new file mode 100644 index 0000000..d7cc6a6 --- /dev/null +++ b/.claude/sessions/oss-136/architecture.md @@ -0,0 +1,454 @@ +# OSS-136 Epic: Podcast Engine + Background Infrastructure - Architecture + +## 🏗️ High-Level System Architecture + +### Current State (Before Changes) +``` +┌─────────────────────────────────────────────────────────────────────────────────────┐ +│ Current System │ +├─────────────────────────────────────────────────────────────────────────────────────┤ +│ Streamlit UI (pages/5_🎙️_Podcasts.py) │ +│ ├─ Complex 15+ field forms │ +│ ├─ Synchronous processing (blocks UI) │ +│ └─ Direct podcast generation call │ +│ │ +│ Domain Layer (open_notebook/plugins/podcasts.py) │ +│ ├─ PodcastConfig (complex model) │ +│ ├─ PodcastEpisode (simple model) │ +│ └─ Direct podcastfy library usage │ +│ │ +│ Database (SurrealDB) │ +│ ├─ podcast_config (schemaless, complex) │ +│ └─ podcast_episode (basic fields) │ +└─────────────────────────────────────────────────────────────────────────────────────┘ +``` + +### Target State (After Implementation) +``` +┌─────────────────────────────────────────────────────────────────────────────────────┐ +│ New Podcast Engine System │ +├─────────────────────────────────────────────────────────────────────────────────────┤ +│ Streamlit UI (Simplified) │ +│ ├─ Episode Profile selector (3-click workflow) │ +│ ├─ Basic job status display │ +│ └─ Non-blocking async submission │ +│ │ +│ FastAPI Layer (New) │ +│ ├─ POST /api/podcasts/generate │ +│ ├─ GET /api/podcasts/jobs/{job_id} │ +│ ├─ GET /api/episode-profiles │ +│ └─ GET /api/speaker-profiles │ +│ │ +│ Service Layer (New) │ +│ ├─ PodcastService (async operations) │ +│ ├─ EpisodeProfileService (profile management) │ +│ └─ SpeakerProfileService (speaker management) │ +│ │ +│ Background Processing (New) │ +│ ├─ Surreal-Commands Worker │ +│ ├─ Podcast-Creator Integration │ +│ └─ LangGraph Workflow │ +│ │ +│ Database (Enhanced) │ +│ ├─ episode_profile (new schema) │ +│ ├─ speaker_profile (new schema) │ +│ ├─ podcast_episode (enhanced) │ +│ ├─ command (surreal-commands) │ +│ └─ podcast_config (legacy, for migration) │ +└─────────────────────────────────────────────────────────────────────────────────────┘ +``` + +## 🔄 Phase-by-Phase Architecture + +### Phase 1: Async Foundation (OSS-137) + +#### 1.1 Surreal-Commands Integration +```python +# New: api/commands/podcast_commands.py +from surreal_commands import command +from pydantic import BaseModel +from typing import Optional + +class PodcastGenerationInput(BaseModel): + notebook_id: str + episode_profile_name: str + episode_name: str + briefing_suffix: Optional[str] = None + +class PodcastGenerationOutput(BaseModel): + success: bool + episode_id: str + audio_file_path: Optional[str] + error_message: Optional[str] + +@command("generate_podcast") +async def generate_podcast_command( + input_data: PodcastGenerationInput +) -> PodcastGenerationOutput: + # Integration with podcast-creator library + # Return structured results + pass +``` + +#### 1.2 Worker Process Integration +```bash +# supervisord.conf addition +[program:worker] +command=uv run --env-file .env python -m surreal_commands.worker +environment=SURREAL_COMMANDS_MODULES="api.commands.podcast_commands" +stdout_logfile=/dev/stdout +stderr_logfile=/dev/stderr +autorestart=true +``` + +#### 1.3 FastAPI Job Management +```python +# New: api/routers/podcasts.py +from fastapi import APIRouter, HTTPException +from surreal_commands import submit_command, get_command_status + +router = APIRouter() + +@router.post("/podcasts/generate") +async def generate_podcast(request: PodcastGenerationRequest): + cmd_id = submit_command( + "api.commands.podcast_commands", + "generate_podcast", + request.model_dump() + ) + return {"job_id": cmd_id, "status": "submitted"} + +@router.get("/podcasts/jobs/{job_id}") +async def get_podcast_job_status(job_id: str): + status = await get_command_status(job_id) + return {"job_id": job_id, "status": status.status, "result": status.result} +``` + +### Phase 2: Engine Integration (OSS-138) + +#### 2.1 Episode Profile Models +```python +# New: open_notebook/domain/podcast.py +from typing import ClassVar, Optional +from pydantic import Field +from open_notebook.domain.base import ObjectModel + +class EpisodeProfile(ObjectModel): + table_name: ClassVar[str] = "episode_profile" + name: str + description: Optional[str] = None + speaker_config: str # Reference to speaker profile + outline_provider: str + outline_model: str + transcript_provider: str + transcript_model: str + default_briefing: str + num_segments: int = Field(default=5) + migrated_from_podcast_config: Optional[str] = None + +class SpeakerProfile(ObjectModel): + table_name: ClassVar[str] = "speaker_profile" + name: str + description: Optional[str] = None + tts_provider: str + tts_model: str + speakers: list # Array of speaker objects + migrated_from_podcast_config: Optional[str] = None + +class PodcastEpisode(ObjectModel): + table_name: ClassVar[str] = "podcast_episode" + name: str + episode_profile: str # Reference to episode profile used + generation_metadata: dict # Store generation parameters + text: str + audio_file: str + command: Optional[str] = None # Link to surreal-commands job +``` + +#### 2.2 Podcast-Creator Integration +```python +# Enhanced: api/commands/podcast_commands.py +from podcast_creator import create_podcast, configure +from open_notebook.domain.podcast import EpisodeProfile, SpeakerProfile +from open_notebook.domain.notebook import Notebook + +@command("generate_podcast") +async def generate_podcast_command( + input_data: PodcastGenerationInput +) -> PodcastGenerationOutput: + try: + # Load episode profile + episode_profile = await EpisodeProfile.get_by_name(input_data.episode_profile_name) + speaker_profile = await SpeakerProfile.get_by_name(episode_profile.speaker_config) + + # Get notebook context + notebook = await Notebook.get_by_id(input_data.notebook_id) + context = await notebook.get_context() + + # Configure podcast-creator + configure("speakers_config", { + "profiles": { + speaker_profile.name: { + "tts_provider": speaker_profile.tts_provider, + "tts_model": speaker_profile.tts_model, + "speakers": speaker_profile.speakers + } + } + }) + + # Generate briefing + briefing = episode_profile.default_briefing + if input_data.briefing_suffix: + briefing += f"\n\n{input_data.briefing_suffix}" + + # Create podcast + result = await create_podcast( + content=str(context), + briefing=briefing, + episode_name=input_data.episode_name, + output_dir=f"data/podcasts/episodes/{input_data.episode_name}", + speaker_config=speaker_profile.name, + outline_provider=episode_profile.outline_provider, + outline_model=episode_profile.outline_model, + transcript_provider=episode_profile.transcript_provider, + transcript_model=episode_profile.transcript_model, + num_segments=episode_profile.num_segments + ) + + # Save episode record + episode = PodcastEpisode( + name=input_data.episode_name, + episode_profile=episode_profile.name, + generation_metadata={ + "briefing": briefing, + "context_size": len(str(context)), + "num_segments": episode_profile.num_segments + }, + text=str(context), + audio_file=result["final_output_file_path"] + ) + await episode.save() + + return PodcastGenerationOutput( + success=True, + episode_id=episode.id, + audio_file_path=result["final_output_file_path"] + ) + + except Exception as e: + return PodcastGenerationOutput( + success=False, + episode_id=None, + error_message=str(e) + ) +``` + +### Phase 3: UI Modernization (OSS-139) + +#### 3.1 Simplified Streamlit Interface +```python +# Enhanced: pages/5_🎙️_Podcasts.py +import asyncio +import streamlit as st +from open_notebook.domain.podcast import EpisodeProfile, SpeakerProfile, PodcastEpisode +from api.podcast_service import PodcastService + +# Simple episode profile selector +episode_profiles = asyncio.run(EpisodeProfile.get_all()) +profile_names = [ep.name for ep in episode_profiles] + +selected_profile = st.selectbox("Choose Episode Profile", profile_names) +episode_name = st.text_input("Episode Name") +briefing_suffix = st.text_area("Additional Instructions (optional)") + +if st.button("Generate Podcast"): + # Submit async job + job_id = await PodcastService.submit_generation_job( + notebook_id=st.session_state.current_notebook_id, + episode_profile_name=selected_profile, + episode_name=episode_name, + briefing_suffix=briefing_suffix + ) + st.success(f"Podcast generation started. Job ID: {job_id}") + +# Display episodes with job status +episodes = asyncio.run(PodcastEpisode.get_all_with_job_status()) +for episode in episodes: + with st.container(): + st.write(f"**{episode.name}** - Status: {episode.job_status}") + if episode.job_status == "completed": + st.audio(episode.audio_file) +``` + +#### 3.2 Episode Profile Management +```python +# New: pages/components/episode_profile_manager.py +class EpisodeProfileManager: + @staticmethod + def create_default_profiles(): + """Create default episode profiles for common use cases""" + profiles = [ + { + "name": "tech_discussion", + "description": "Technical discussion between experts", + "speaker_config": "tech_experts", + "default_briefing": "Create an engaging technical discussion about the provided content..." + }, + { + "name": "solo_expert", + "description": "Single expert explaining complex topics", + "speaker_config": "solo_expert", + "default_briefing": "Explain the content in an accessible, educational way..." + }, + # More profiles... + ] + return profiles +``` + +### Phase 4: Data Migration (OSS-141) + +#### 4.1 Migration Strategy +```python +# New: migrations/7.surrealql (handled by Luis) +# Create new tables +DEFINE TABLE episode_profile SCHEMAFULL; +DEFINE TABLE speaker_profile SCHEMAFULL; +# ... field definitions + +# Migration script (handled by Luis) +# Translate old podcast_config fields to new format +# Create default profiles based on common configurations +``` + +## 🔗 Component Dependencies & Relationships + +### External Dependencies +```toml +# pyproject.toml additions +dependencies = [ + "surreal-commands>=1.0.0", + "podcast-creator>=0.2.0", + # ... existing dependencies +] +``` + +### Internal Component Flow +``` +┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ +│ Streamlit UI │───▶│ FastAPI │───▶│ Service │ +│ (3-click) │ │ (async) │ │ Layer │ +└─────────────────┘ └─────────────────┘ └─────────────────┘ + │ + ▼ +┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ +│ SurrealDB │◀───│ Background │◀───│ Surreal- │ +│ (job status) │ │ Worker │ │ Commands │ +└─────────────────┘ └─────────────────┘ └─────────────────┘ + │ + ▼ + ┌─────────────────┐ + │ Podcast- │ + │ Creator │ + │ (LangGraph) │ + └─────────────────┘ +``` + +## 🎯 Design Patterns & Best Practices + +### 1. Async-First Architecture +- All new components use async/await patterns +- Consistent with existing codebase patterns +- Non-blocking UI experience + +### 2. Domain-Driven Design +- Clear separation: Domain models, Service layer, API layer +- Follows existing `ObjectModel` patterns +- Consistent with current architecture + +### 3. Command Pattern +- Surreal-commands for background processing +- Structured input/output models +- Error handling and status tracking + +### 4. Configuration Management +- Episode Profiles for simplified user experience +- Speaker Profiles for reusable voice configurations +- Migration-friendly design + +## 📁 File Structure & Modifications + +### New Files to Create +``` +api/ +├── commands/ +│ └── podcast_commands.py # Surreal-commands integration +├── routers/ +│ └── podcasts.py # FastAPI podcast endpoints +└── podcast_service.py # Service layer for podcast operations + +open_notebook/ +└── domain/ + └── podcast.py # New domain models (Episode/Speaker Profiles) + +supervisord.conf # Add worker process configuration +``` + +### Files to Modify +``` +api/main.py # Add podcast router +pages/5_🎙️_Podcasts.py # Simplified UI implementation +open_notebook/plugins/podcasts.py # Enhanced with new models +``` + +### Files to Migrate (Phase 4) +``` +migrations/7.surrealql # New schema (handled by Luis) +migrations/7_down.surrealql # Rollback script +``` + +## ⚡ Performance & Scalability + +### Async Processing Benefits +- **Non-blocking UI**: Users can continue working while podcasts generate +- **Scalable Design**: Foundation for future background processing +- **Resource Management**: Worker process isolation + +### Database Optimization +- **Structured Schema**: Move from schemaless to schemafull for better performance +- **Efficient Queries**: Profile-based lookups vs complex configuration parsing +- **Status Tracking**: Simple relationship-based job status + +## 🛡️ Error Handling & Monitoring + +### Command Error Handling +```python +@command("generate_podcast") +async def generate_podcast_command(input_data: PodcastGenerationInput): + try: + # ... podcast generation logic + return PodcastGenerationOutput(success=True, ...) + except ValidationError as e: + return PodcastGenerationOutput(success=False, error_message=f"Invalid input: {e}") + except Exception as e: + logger.error(f"Podcast generation failed: {e}") + return PodcastGenerationOutput(success=False, error_message=str(e)) +``` + +### Status Monitoring +- Command status tracking via surreal-commands +- Simple UI updates through database relationships +- Structured error messages for debugging + +## 🔄 Migration Strategy + +### Backward Compatibility +- Existing `podcast_config` table remains during migration +- Gradual migration of user configurations +- Fallback mechanisms for legacy data + +### Data Translation +- Old configuration fields mapped to new Episode Profile format +- Default profiles created for common use cases +- Migration script handles complex configurations + +This architecture provides a solid foundation for the podcast engine while maintaining consistency with existing codebase patterns and ensuring a smooth migration path. \ No newline at end of file diff --git a/.claude/sessions/oss-136/context.md b/.claude/sessions/oss-136/context.md new file mode 100644 index 0000000..2ede0bc --- /dev/null +++ b/.claude/sessions/oss-136/context.md @@ -0,0 +1,133 @@ +# OSS-136 Epic: Podcast Engine + Background Infrastructure - Context + +## 🎯 Project Vision +Create a proprietary podcast generation engine that serves as Open Notebook's competitive differentiator against Google Notebook LM, while establishing the foundation for all background processing using proven open-source libraries. + +## 📋 Current Implementation Analysis + +### Existing System (to be replaced) +- **Technology**: Uses `podcastfy` library (synchronous) +- **Database**: `podcast_config` (complex 15+ fields) and `podcast_episode` tables +- **UI**: Complex Streamlit forms with manual field configuration +- **Processing**: Synchronous - blocks UI during generation +- **Location**: `open_notebook/plugins/podcasts.py` and `pages/5_🎙️_Podcasts.py` + +### Key Current Features +- Multiple TTS providers (OpenAI, Anthropic, Google, ElevenLabs) +- Detailed speaker configuration (roles, personalities, voices) +- Conversation styles and dialogue structures +- Episode management and audio playback + +## 🚀 Strategic Value & Competitive Advantages + +### Democratization Impact +- **User Choice**: Flexible 1-4 speakers vs Google's fixed 2-host format +- **Model Freedom**: User selects LLM + TTS providers via Esperanto integration +- **Local Privacy**: Complete support for local audio models and processing +- **Customization**: Rich speaker personalities, backstories, and editable prompts + +### Technical Foundation +- **Battle-tested Infrastructure**: Proven surreal-commands for background processing +- **Professional Engine**: Production-ready podcast-creator library with advanced features +- **Ecosystem Consistency**: LangChain Runnable patterns across all async operations +- **Scalable Architecture**: Foundation for Content Composer, Deep Research, and future workflows + +## 🔄 Implementation Strategy (Updated Based on Clarifications) + +### Phase 1: Async Foundation (OSS-137) +- **Technology**: Surreal-commands integration in same container +- **Worker**: Single worker using existing supervisord.conf +- **Processing**: Async job queue with SurrealDB backend +- **Status**: Simple status via podcast_episode → command relationship + +### Phase 2: Engine Integration (OSS-138) +- **Technology**: Podcast-creator library with Episode Profiles +- **Migration**: From 15+ fields to simplified 3-click workflow +- **Compatibility**: Translation of old fields into new system (briefing concatenation) +- **Profiles**: Default Episode and Speaker profiles for common use cases + +### Phase 3: UI Modernization (OSS-139) +- **Focus**: Simplified Episode Profile selector + basic job status +- **Approach**: Build UI after async foundation is ready +- **No**: Real-time updates, WebSockets, complex status tracking +- **Yes**: Simple page refresh for status updates, preparing for React migration + +### Phase 4: Data Migration (OSS-141) +- **Timing**: Last phase, handled in parallel by Luis +- **Strategy**: Automatic translation of existing configs to Episode Profiles +- **Compatibility**: Heavy customizations handled by migration script +- **Database**: New tables for episode_profile and speaker_profile + +## 🔧 Technical Architecture + +### New Database Schema (Migration 7) +```sql +-- episode_profile table +DEFINE TABLE episode_profile SCHEMAFULL; +DEFINE FIELD name ON TABLE episode_profile TYPE string; +DEFINE FIELD description ON TABLE episode_profile TYPE option; +DEFINE FIELD speaker_config ON TABLE episode_profile TYPE string; +DEFINE FIELD outline_provider ON TABLE episode_profile TYPE string; +DEFINE FIELD outline_model ON TABLE episode_profile TYPE string; +DEFINE FIELD transcript_provider ON TABLE episode_profile TYPE string; +DEFINE FIELD transcript_model ON TABLE episode_profile TYPE string; +DEFINE FIELD default_briefing ON TABLE episode_profile TYPE string; +DEFINE FIELD num_segments ON TABLE episode_profile TYPE int; + +-- speaker_profile table +DEFINE TABLE speaker_profile SCHEMAFULL; +DEFINE FIELD name ON TABLE speaker_profile TYPE string; +DEFINE FIELD tts_provider ON TABLE speaker_profile TYPE string; +DEFINE FIELD tts_model ON TABLE speaker_profile TYPE string; +DEFINE FIELD speakers ON TABLE speaker_profile TYPE array; +``` + +### Component Integration +- **Surreal-Commands**: Async job processing with SurrealDB LIVE queries +- **Podcast-Creator**: Episode Profiles with LangGraph workflow +- **FastAPI**: New async endpoints for podcast generation +- **Streamlit**: Simplified UI with Episode Profile selection + +### Worker Architecture +- **Container**: Same container as main app +- **Supervisor**: Existing supervisord.conf with new worker service +- **Scalability**: Single worker only (surreal-commands current limitation) +- **Processing**: Background job queue with status tracking + +## 🎯 Success Metrics + +### Technical Metrics +- **Generation Time**: ~2-3 minutes for professional quality +- **Concurrency**: Non-blocking UI during generation +- **Flexibility**: 1-4 speaker support vs Google's 2-host limit +- **Quality**: Professional podcast output with rich speaker personalities + +### User Experience Metrics +- **Simplicity**: 3-click workflow (profile → name → generate) +- **Accessibility**: Episode Profiles for non-technical users +- **Transparency**: Clear job status without complex real-time updates +- **Flexibility**: Custom profiles for advanced users + +## 📝 Implementation Notes + +### Constraints +- **No Tests**: Testing will be handled in separate epic +- **No Real-time**: Simple refresh-based status updates in Streamlit +- **Single Worker**: Current surreal-commands limitation +- **Migration**: Luis will handle DB schema and migration scripts + +### Dependencies +- **Libraries**: surreal-commands and podcast-creator already proven +- **Integration**: Esperanto for multi-provider support +- **Infrastructure**: Existing SurrealDB and supervisord setup +- **Migration**: Database schema changes handled in parallel + +### Key Files to Modify/Create +- `api/routers/podcasts.py` - New FastAPI endpoints +- `api/podcast_service.py` - Service layer for async operations +- `pages/5_🎙️_Podcasts.py` - Simplified UI with Episode Profiles +- `open_notebook/plugins/podcasts.py` - Updated models and logic +- `supervisord.conf` - Worker process configuration +- Migration scripts (handled by Luis) + +This implementation will establish Open Notebook as a superior alternative to Google Notebook LM while creating a robust foundation for future async processing features. \ No newline at end of file diff --git a/.claude/sessions/oss-136/plan.md b/.claude/sessions/oss-136/plan.md new file mode 100644 index 0000000..e9b6492 --- /dev/null +++ b/.claude/sessions/oss-136/plan.md @@ -0,0 +1,1795 @@ +# OSS-136 Epic: Podcast Engine + Background Infrastructure - Implementation Plan + +## Overview + +This plan breaks down the implementation of the new podcast engine and background infrastructure into manageable phases of approximately 3-4 hours each. Each phase is designed to be independent, testable, and builds upon the previous phase to create a competitive advantage against Google Notebook LM. + +**Total Estimated Time**: 14-16 hours across 4 phases +**Risk Level**: Medium (new async architecture with proven libraries) +**Rollback Strategy**: Independent commits for each phase +**Dependencies**: surreal-commands, podcast-creator (both proven libraries) + +**Strategic Goal**: Create 1-4 speaker flexibility vs Google's 2-host limitation with simplified Episode Profile workflow + +--- + +## Phase 1: Async Foundation (OSS-137) - 4 hours + +Surreal Commands Library: https://github.com/lfnovo/surreal-commands +Also available in Context7 and on /Users/luisnovo/dev/projetos/surreal-commands/surreal-commands + +### 🎯 Goals +- Integrate surreal-commands for background job processing +- Create generic command infrastructure with example commands +- Set up worker process in existing container using supervisord +- Add Makefile command to start worker in dev environment +- Establish command-based architecture foundation for all future background processing + +### 📁 Files to Create/Change +1. **NEW**: `commands/example_commands.py` - Generic command examples for testing (moved from /api/commands) +2. **NEW**: `commands/__init__.py` - Commands module initialization +3. **NEW**: `api/routers/commands.py` - Generic command execution endpoints +4. **NEW**: `api/command_service.py` - Generic service layer for command operations +5. **MODIFY**: `api/main.py` - Add commands router and import commands module +6. **MODIFY**: `supervisord.conf` - Add worker process +7. **MODIFY**: `pyproject.toml` - Add surreal-commands dependency +8. **MODIFY**: `Makefile` - Add worker start/stop/restart commands +9. **NEW**: `test_commands.sh` - Testing script for manual verification + +### 🔧 Specific Implementation Steps + +#### 1.1 Add Dependencies +```toml +# pyproject.toml - Add to dependencies array +dependencies = [ + # ... existing dependencies + "surreal-commands>=1.0.7", +] +``` + +#### 1.2 Create Generic Command Infrastructure +```python +# commands/__init__.py +"""Surreal-commands integration for Open Notebook""" + +# commands/example_commands.py +from surreal_commands import command +from pydantic import BaseModel +from typing import Optional, List +from loguru import logger +import asyncio +import time + +class TextProcessingInput(BaseModel): + text: str + operation: str = "uppercase" # uppercase, lowercase, word_count, reverse + delay_seconds: Optional[int] = None # For testing async behavior + +class TextProcessingOutput(BaseModel): + success: bool + original_text: str + processed_text: Optional[str] = None + word_count: Optional[int] = None + processing_time: float + error_message: Optional[str] = None + +class DataAnalysisInput(BaseModel): + numbers: List[float] + analysis_type: str = "basic" # basic, detailed + delay_seconds: Optional[int] = None + +class DataAnalysisOutput(BaseModel): + success: bool + analysis_type: str + count: int + sum: Optional[float] = None + average: Optional[float] = None + min_value: Optional[float] = None + max_value: Optional[float] = None + processing_time: float + error_message: Optional[str] = None + +@command("process_text", app="open_notebook") +async def process_text_command(input_data: TextProcessingInput) -> TextProcessingOutput: + """ + Example command for text processing. Tests basic command functionality + and demonstrates different processing types. + """ + start_time = time.time() + + try: + logger.info(f"Processing text with operation: {input_data.operation}") + + # Simulate processing delay if specified + if input_data.delay_seconds: + await asyncio.sleep(input_data.delay_seconds) + + processed_text = None + word_count = None + + if input_data.operation == "uppercase": + processed_text = input_data.text.upper() + elif input_data.operation == "lowercase": + processed_text = input_data.text.lower() + elif input_data.operation == "reverse": + processed_text = input_data.text[::-1] + elif input_data.operation == "word_count": + word_count = len(input_data.text.split()) + processed_text = f"Word count: {word_count}" + else: + raise ValueError(f"Unknown operation: {input_data.operation}") + + processing_time = time.time() - start_time + + return TextProcessingOutput( + success=True, + original_text=input_data.text, + processed_text=processed_text, + word_count=word_count, + processing_time=processing_time + ) + + except Exception as e: + processing_time = time.time() - start_time + logger.error(f"Text processing failed: {e}") + return TextProcessingOutput( + success=False, + original_text=input_data.text, + processing_time=processing_time, + error_message=str(e) + ) + +@command("analyze_data", app="open_notebook") +async def analyze_data_command(input_data: DataAnalysisInput) -> DataAnalysisOutput: + """ + Example command for data analysis. Tests command with complex input/output + and demonstrates error handling. + """ + start_time = time.time() + + try: + logger.info(f"Analyzing {len(input_data.numbers)} numbers with {input_data.analysis_type} analysis") + + # Simulate processing delay if specified + if input_data.delay_seconds: + await asyncio.sleep(input_data.delay_seconds) + + if not input_data.numbers: + raise ValueError("No numbers provided for analysis") + + count = len(input_data.numbers) + sum_value = sum(input_data.numbers) + average = sum_value / count + min_value = min(input_data.numbers) + max_value = max(input_data.numbers) + + processing_time = time.time() - start_time + + return DataAnalysisOutput( + success=True, + analysis_type=input_data.analysis_type, + count=count, + sum=sum_value, + average=average, + min_value=min_value, + max_value=max_value, + processing_time=processing_time + ) + + except Exception as e: + processing_time = time.time() - start_time + logger.error(f"Data analysis failed: {e}") + return DataAnalysisOutput( + success=False, + analysis_type=input_data.analysis_type, + count=0, + processing_time=processing_time, + error_message=str(e) + ) +``` + +#### 1.3 Create Generic Command Service Layer +```python +# api/command_service.py +from typing import List, Optional, Dict, Any +from loguru import logger +from surreal_commands import submit_command, get_command_status +from api.models import ErrorResponse + +class CommandService: + """Generic service layer for command operations""" + + @staticmethod + async def submit_command_job( + module_name: str, + command_name: str, + command_args: Dict[str, Any], + context: Optional[Dict[str, Any]] = None + ) -> str: + """Submit a generic command job for background processing""" + try: + cmd_id = submit_command( + module_name, + command_name, + command_args, + context=context + ) + logger.info(f"Submitted command job: {cmd_id} for {module_name}.{command_name}") + return cmd_id + + except Exception as e: + logger.error(f"Failed to submit command job: {e}") + raise + + @staticmethod + async def get_command_status(job_id: str) -> Dict[str, Any]: + """Get status of any command job""" + try: + status = await get_command_status(job_id) + return { + "job_id": job_id, + "status": status.status if status else "unknown", + "result": status.result if status else None, + "error_message": status.error_message if status else None, + "created": str(status.created) if status and status.created else None, + "updated": str(status.updated) if status and status.updated else None, + "progress": status.progress if status else None + } + except Exception as e: + logger.error(f"Failed to get command status: {e}") + raise + + @staticmethod + async def list_command_jobs( + module_filter: Optional[str] = None, + command_filter: Optional[str] = None, + status_filter: Optional[str] = None, + limit: int = 50 + ) -> List[Dict[str, Any]]: + """List command jobs with optional filtering""" + # This will be implemented with proper SurrealDB queries + # For now, return empty list as this is foundation phase + return [] + + @staticmethod + async def cancel_command_job(job_id: str) -> bool: + """Cancel a running command job""" + try: + # Implementation depends on surreal-commands cancellation support + # For now, just log the attempt + logger.info(f"Attempting to cancel job: {job_id}") + return True + except Exception as e: + logger.error(f"Failed to cancel command job: {e}") + raise +``` + +#### 1.4 Create Generic Command Endpoints +```python +# api/routers/commands.py +from typing import List, Optional, Dict, Any +from fastapi import APIRouter, HTTPException, Query +from pydantic import BaseModel, Field +from loguru import logger + +from api.command_service import CommandService +from api.models import ErrorResponse + +router = APIRouter() + +class CommandExecutionRequest(BaseModel): + command: str = Field(..., description="Command function name (e.g., 'process_text')") + app: str = Field(..., description="Application name (e.g., 'open_notebook')") + input: Dict[str, Any] = Field(..., description="Arguments to pass to the command") + +class CommandJobResponse(BaseModel): + job_id: str + status: str + message: str + +class CommandJobStatusResponse(BaseModel): + job_id: str + status: str + result: Optional[Dict[str, Any]] = None + error_message: Optional[str] = None + created: Optional[str] = None + updated: Optional[str] = None + progress: Optional[Dict[str, Any]] = None + +@router.post("/commands/jobs", response_model=CommandJobResponse) +async def execute_command(request: CommandExecutionRequest): + """ + Submit a command for background processing. + Returns immediately with job ID for status tracking. + """ + # parameters + "command": "generate_podcast", + "app": "open_notebook", + "input": { "notebook_id": "123", "episode_profile": "tech" } + + +@router.get("/commands/{job_id}", response_model=CommandJobStatusResponse) +async def get_command_job_status(job_id: str): + """Get the status of a specific command job""" + try: + status_data = await CommandService.get_command_status(job_id) + return CommandJobStatusResponse(**status_data) + + except Exception as e: + logger.error(f"Error fetching job status: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to fetch job status: {str(e)}" + ) + +@router.get("/commands/jobs", response_model=List[Dict[str, Any]]) +async def list_command_jobs( + command_filter: Optional[str] = Query(None, description="Filter by command name"), + status_filter: Optional[str] = Query(None, description="Filter by status"), + limit: int = Query(50, description="Maximum number of jobs to return") +): + """List command jobs with optional filtering""" + try: + jobs = await CommandService.list_command_jobs( + command_filter=command_filter, + status_filter=status_filter, + limit=limit + ) + return jobs + + except Exception as e: + logger.error(f"Error listing command jobs: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to list command jobs: {str(e)}" + ) + +@router.delete("/commands/jobs/{job_id}") +async def cancel_command_job(job_id: str): + """Cancel a running command job""" + try: + success = await CommandService.cancel_command_job(job_id) + return {"job_id": job_id, "cancelled": success} + + except Exception as e: + logger.error(f"Error cancelling command job: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to cancel command job: {str(e)}" + ) + +``` + +#### 1.5 Add Router to Main App +```python +# api/main.py - Add import and router +from api.routers import notebooks, search, models, transformations, notes, embedding, settings, context, sources, insights +from api.routers import commands as commands_router + +# Import commands to register them in the API process +try: + import commands.example_commands + from loguru import logger + logger.info("Commands imported in API process") +except Exception as e: + from loguru import logger + logger.error(f"Failed to import commands in API process: {e}") + +# Add to router includes (after line 31) +app.include_router(commands_router.router, prefix="/api", tags=["commands"]) +``` + +#### 1.6 Configure Worker Process +```bash +# supervisord.conf - Add after [program:api] section +[program:worker] +command=uv run --env-file .env surreal-commands-worker --import-modules commands.example_commands +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 +stderr_logfile=/dev/stderr +stderr_logfile_maxbytes=0 +autorestart=true +``` + +#### 1.7 Add Makefile Commands +```makefile +# Makefile - Add worker management commands +.PHONY: worker worker-start worker-stop worker-restart + +worker: worker-start + +worker-start: + @echo "Starting surreal-commands worker..." + uv run --env-file .env surreal-commands-worker --import-modules commands.example_commands + +worker-stop: + @echo "Stopping surreal-commands worker..." + pkill -f "surreal-commands-worker" || true + +worker-restart: worker-stop + @sleep 2 + @$(MAKE) worker-start + +``` + +### ✅ Testing Strategy +1. **Dependencies**: Verify surreal-commands installs correctly +2. **Worker Process**: Test worker starts and registers example commands successfully +3. **API Endpoints**: Test generic command submission and status retrieval +4. **Command Execution**: Verify example commands execute and return expected results +5. **Error Handling**: Test error scenarios and proper error responses +6. **Async Behavior**: Test commands with delays to verify non-blocking execution + +### 🧪 Manual Testing Commands +```bash +# 1. Install dependencies +uv sync + +# 2. Start SurrealDB +make database + +# 3. Start API and worker separately for testing +# Terminal 1: Start API +make api + +# Terminal 2: Start worker +make worker + +# 4. Test example command endpoints (shortcuts) +curl -X POST "http://localhost:5055/api/commands/jobs" \ + -H "Content-Type: application/json" \ + -d '{ + params + } + }' + + +# 6. Check job status (use job_id from responses) +curl "http://localhost:5055/api/commands/jobs/{job_id}" + +# 7. List all command jobs +curl "http://localhost:5055/api/commands/jobs" + +# 8. Test worker with supervisord (production mode) +docker compose up + +# 9. Test Makefile commands +make worker-start +make worker-stop +make worker-restart +``` + +### ⚠️ Critical Notes +- **Worker Process**: Single worker only (surreal-commands current limitation) +- **Environment Setup**: Ensure SurrealDB is running before starting worker +- **Testing Required**: Thoroughly test async job submission and status tracking +- **🛑 STOP**: Request human approval before proceeding to Phase 2 + +--- + +## Phase 2: Engine Integration (OSS-138) - 4 hours + +### 📚 Dependencies +- Surreal Commands Library: https://github.com/lfnovo/surreal-commands +- Available in Context7 and on /Users/luisnovo/dev/projetos/surreal-commands/surreal-commands +- Podcast Creator Library: https://github.com/lfnovo/podcast-creator +- Available in Context7 and on /Users/luisnovo/dev/projetos/podcast-creator/podcast-creator + +### 🎯 Goals +- Integrate podcast-creator library with Episode Profiles +- Create domain models for Episode and Speaker profiles +- Implement real podcast generation with LangGraph workflow +- Replace placeholder implementation with production-ready engine + +### 📁 Files to Create/Change +1. **NEW**: `open_notebook/domain/podcast.py` - Episode, Speaker, PodcastEpisode models +2. **NEW**: `api/routers/episode_profiles.py` - Episode profile management endpoints +3. **NEW**: `api/routers/speaker_profiles.py` - Speaker profile management endpoints +4. **MODIFY**: `commands/podcast_commands.py` - Real podcast generation implementation +5. **MODIFY**: `api/main.py` - Add new routers +6. **DELETE AT THE END**: `plugins/podcasts.py` - Old Podcast module that we are replacing + + +### 🔧 Before you start + +Database models have already been created + +Referer to the file 7.surrealql to see that has already been created. + + +### 🔧 Specific Implementation Steps + + +#### 2.1 Create Domain Models +```python +# open_notebook/domain/podcast.py +from typing import ClassVar, Optional, List, Dict, Any +from pydantic import Field, validator +from open_notebook.domain.base import ObjectModel + +class EpisodeProfile(ObjectModel): + """ + Episode Profile - Simplified podcast configuration. + Replaces complex 15+ field configuration with user-friendly profiles. + """ + table_name: ClassVar[str] = "episode_profile" + + name: str = Field(..., description="Unique profile name") + description: Optional[str] = Field(None, description="Profile description") + speaker_config: str = Field(..., description="Reference to speaker profile name") + outline_provider: str = Field(..., description="AI provider for outline generation") + outline_model: str = Field(..., description="AI model for outline generation") + transcript_provider: str = Field(..., description="AI provider for transcript generation") + transcript_model: str = Field(..., description="AI model for transcript generation") + default_briefing: str = Field(..., description="Default briefing template") + num_segments: int = Field(default=5, description="Number of podcast segments") + + @validator('num_segments') + def validate_segments(cls, v): + if not 3 <= v <= 20: + raise ValueError('Number of segments must be between 3 and 20') + return v + + @classmethod + async def get_by_name(cls, name: str) -> Optional['EpisodeProfile']: + """Get episode profile by name""" + from open_notebook.database.repository import repo_query, ensure_record_id + result = await repo_query( + "SELECT * FROM episode_profile WHERE name = $name", + {"name": name} + ) + if result: + return cls(**result[0]) + return None + +class SpeakerProfile(ObjectModel): + """ + Speaker Profile - Voice and personality configuration. + Supports 1-4 speakers for flexible podcast formats. + """ + table_name: ClassVar[str] = "speaker_profile" + + name: str = Field(..., description="Unique profile name") + description: Optional[str] = Field(None, description="Profile description") + tts_provider: str = Field(..., description="TTS provider (openai, elevenlabs, etc.)") + tts_model: str = Field(..., description="TTS model name") + speakers: List[Dict[str, Any]] = Field(..., description="Array of speaker configurations") + + @validator('speakers') + def validate_speakers(cls, v): + if not 1 <= len(v) <= 4: + raise ValueError('Must have between 1 and 4 speakers') + + required_fields = ['name', 'voice_id', 'backstory', 'personality'] + for speaker in v: + for field in required_fields: + if field not in speaker: + raise ValueError(f'Speaker missing required field: {field}') + return v + + @classmethod + async def get_by_name(cls, name: str) -> Optional['SpeakerProfile']: + """Get speaker profile by name""" + from open_notebook.database.repository import repo_query + result = await repo_query( + "SELECT * FROM speaker_profile WHERE name = $name", + {"name": name} + ) + if result: + return cls(**result[0]) + return None + +from surrealdb import RecordID + +class PodcastEpisode(ObjectModel): + """Enhanced PodcastEpisode with job tracking and metadata""" + table_name: ClassVar[str] = "episode" + + name: str + episode_profile: str = Field(..., description="Episode profile used") + generation_metadata: Dict[str, Any] = Field(default_factory=dict, description="Generation parameters") + briefing: str = Field(..., description="Full briefing used for generation") + text: str = Field(..., description="Source content") + audio_file: Optional[str] = Field(None, description="Path to generated audio file") + transcript_file: Optional[str] = Field(None, description="Path to transcript file") + outline_file: Optional[str] = Field(None, description="Path to outline file") + command: Optional[Union[str, RecordID]] = Field(None, description="Link to surreal-commands job") + + async def get_job_status(self) -> Optional[str]: + """Get the status of the associated command""" + if not self.command: + return None + + from surreal_commands import get_command_status + try: + status = await get_command_status(self.command) + return status.status if status else "unknown" + except Exception: + return "unknown" +``` + +#### 2.2 - Load the episode_profile and speaker_profile objects from SurrealDB into podcast-creator using its configure methods and Create the command + +Look for a reference on commands/example_commands.py or look in the surreal-commands documentation for more details on how to create a command + +Your command will get the speaker_profile, episode_profile, episode_name, additional_briefing and content as input and will generate the podcast episode +set output_dir as os.environ.get("DATA_DIR", "/podcasts") + +The command will call the generate_podcast method from podcast_creator with the following parameters: + +- output_dir +- episode_profile +- episode_name +- additional_briefing +- content + +```python + +# commands/podcast_commands.py +from podcast_creator import configure + +# get the profiles +episode_profiles = await repo_query("select * from episode_profile") +speaker_profiles = await repo_query("select * from speaker_profile") + +# transform the surrealdb array into a dictionary so you can pass them to config like this: + +episode_profiles_dict = {profile["name"]: profile for profile in episode_profiles} +speaker_profiles_dict = {profile["name"]: profile for profile in speaker_profiles} + +# Define custom episode profiles +configure("episode_config", { + "profiles": episode_profiles_dict +}) + +configure("speaker_config", { + "profiles": speaker_profiles_dict +}) + + +# commands/podcast_commands.py - Replace placeholder with real implementation +from podcast_creator import create_podcast, configure +from open_notebook.domain.podcast import EpisodeProfile, SpeakerProfile, PodcastEpisode +from open_notebook.domain.notebook import Notebook +from pathlib import Path +import json + +@command("generate_podcast") +async def generate_podcast_command( + input_data: PodcastGenerationInput +) -> PodcastGenerationOutput: + """ + Real podcast generation using podcast-creator library with Episode Profiles + """ + try: + logger.info(f"Starting podcast generation for episode: {input_data.episode_name}") + + # 1. Load Episode and Speaker profiles + episode_profile = await EpisodeProfile.get_by_name(input_data.episode_profile_name) + speaker_profile = await SpeakerProfile.get_by_name(episode_profile.speaker_config) + + # 4. Generate briefing + briefing = episode_profile.default_briefing + if input_data.briefing_suffix: + briefing += f"\n\nAdditional instructions: {input_data.briefing_suffix}" + + # 5. Create output directory + output_dir = Path(f"{os.environ.get('DATA_DIR', '/podcasts')}/episodes/{input_data.episode_name}") + output_dir.mkdir(parents=True, exist_ok=True) + + # 6. Generate podcast using podcast-creator + result = await create_podcast( + content=input_data.content, + briefing=briefing, + episode_name=input_data.episode_name, + output_dir=str(output_dir), + speaker_profile=speaker_profile.name, + podcast_profile=episode_profile.name, + + ) + + # 7. Save episode record + episode = PodcastEpisode( + name=input_data.episode_name, + episode_profile=episode_profile.model_dump(), + speaker_profile=speaker_profile.model_dump(), + briefing=briefing, + content=str(context), + audio_file=result.get("final_output_file_path"), + transcript=result.get("transcript"), + outline=result.get("outline") + ) + await episode.save() + + logger.info(f"Successfully generated podcast episode: {episode.id}") + + return PodcastGenerationOutput( + success=True, + episode_id=str(episode.id), + audio_file_path=result.get("final_output_file_path"), + ) + + except Exception as e: + logger.error(f"Podcast generation failed: {e}") + return PodcastGenerationOutput( + success=False, + error_message=str(e) + ) + +``` + +#### 2.3 - Create the API endpoint for podcast generation and the esrvice that will service the API and submit the command to surreal-commands + +POST /podcast/episode + + + +#### 2.4 Create Profile Management Endpoints +```python +# api/routers/episode_profiles.py +from typing import List +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel, Field +from open_notebook.domain.podcast import EpisodeProfile +from api.models import ErrorResponse + +router = APIRouter() + +class EpisodeProfileResponse(BaseModel): + id: str + name: str + description: str + speaker_config: str + outline_provider: str + outline_model: str + transcript_provider: str + transcript_model: str + default_briefing: str + num_segments: int + +@router.get("/episode-profiles", response_model=List[EpisodeProfileResponse]) +async def list_episode_profiles(): + """List all available episode profiles""" + try: + profiles = await EpisodeProfile.get_all(order_by="name asc") + return [ + EpisodeProfileResponse( + id=profile.id, + name=profile.name, + description=profile.description or "", + speaker_config=profile.speaker_config, + outline_provider=profile.outline_provider, + outline_model=profile.outline_model, + transcript_provider=profile.transcript_provider, + transcript_model=profile.transcript_model, + default_briefing=profile.default_briefing, + num_segments=profile.num_segments + ) + for profile in profiles + ] + except Exception as e: + raise HTTPException( + status_code=500, + detail=f"Failed to fetch episode profiles: {str(e)}" + ) + +# api/routers/speaker_profiles.py +from typing import List, Dict, Any +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel +from open_notebook.domain.podcast import SpeakerProfile + +router = APIRouter() + +class SpeakerProfileResponse(BaseModel): + id: str + name: str + description: str + tts_provider: str + tts_model: str + speakers: List[Dict[str, Any]] + +@router.get("/speaker-profiles", response_model=List[SpeakerProfileResponse]) +async def list_speaker_profiles(): + """List all available speaker profiles""" + try: + profiles = await SpeakerProfile.get_all(order_by="name asc") + return [ + SpeakerProfileResponse( + id=profile.id, + name=profile.name, + description=profile.description or "", + tts_provider=profile.tts_provider, + tts_model=profile.tts_model, + speakers=profile.speakers + ) + for profile in profiles + ] + except Exception as e: + raise HTTPException( + status_code=500, + detail=f"Failed to fetch speaker profiles: {str(e)}" + ) +``` + +### ✅ Testing Strategy +1. **Profile Management**: Test episode and speaker profile CRUD operations +2. **Real Generation**: Test end-to-end podcast generation through the API -> surreal-commands -> podcast-creator +3. **Error Handling**: Test various failure scenarios (missing profiles, invalid content) +4. **Integration**: Verify podcast-creator integration with Episode Profiles + + +### 🧪 Manual Testing Commands +```bash + +# 2. List available profiles +curl "http://localhost:5055/api/episode-profiles" +curl "http://localhost:5055/api/speaker-profiles" + +# 3. Generate real podcast +curl -X POST "http://localhost:5055/api/podcasts/episodes" \ + -H "Content-Type: application/json" \ + -d '{ + "episode_profile_name": "tech_discussion", + "content": "My first episode", + "episode_name": "my_first_episode" + "briefing_suffix": "Additional instructions blabla" + "speaker_profile_name": "tech_experts" + }' + +# 4. Monitor job progress +curl "http://localhost:5055/api/commands/jobs/{job_id}" +``` + +### ⚠️ Critical Notes +- **Real Audio Generation**: This phase produces actual podcast audio files (~2-3 minutes) +- **Error Recovery**: Implement proper cleanup on generation failure +- **🛑 STOP**: Request human approval before proceeding to Phase 3 + +--- + +## Phase 3: UI Modernization (OSS-139) - 3 hours + +### 🎯 Goals +- Simplify Streamlit UI from 15+ fields to 3-click workflow (Profile → Name → Generate) +- Display podcast episodes with job status via database relationships +- Implement non-blocking podcast generation UX +- Prepare UI foundation for future React migration + +### 📁 Files to Create/Change +1. **MODIFY**: `pages/5_🎙️_Podcasts.py` - Complete UI overhaul (make a backup before starting) +2. **NEW**: `pages/components/episode_profile_selector.py` - Profile selection component +3. **NEW**: `pages/components/podcast_status_display.py` - Status display component +4. **MODIFY**: `pages/stream_app/chat.py` - Update podcast tab integration + +### 🔧 Specific Implementation Steps + +#### 3.1 Create Profile Selection Component +```python +# pages/components/episode_profile_selector.py +import asyncio +import streamlit as st +from typing import List, Optional +from open_notebook.domain.podcast import EpisodeProfile, SpeakerProfile + +class EpisodeProfileSelector: + """Component for selecting episode profiles with preview""" + + @staticmethod + async def render() -> Optional[str]: + """Render episode profile selector and return selected profile name""" + + # Load available profiles + profiles = asyncio.run(EpisodeProfile.get_all(order_by="name asc")) + + if not profiles: + st.error("No episode profiles available. Please contact administrator.") + return None + + # Create profile options with descriptions + profile_options = {} + for profile in profiles: + display_name = f"{profile.name} - {profile.description}" if profile.description else profile.name + profile_options[display_name] = profile.name + + # Profile selection + selected_display = st.selectbox( + "Choose Episode Profile", + options=list(profile_options.keys()), + help="Select a pre-configured podcast style" + ) + + if selected_display: + selected_name = profile_options[selected_display] + selected_profile = next(p for p in profiles if p.name == selected_name) + + # Show profile preview + with st.expander("📝 Profile Details", expanded=False): + st.write(f"**Description:** {selected_profile.description or 'No description'}") + st.write(f"**Speaker Configuration:** {selected_profile.speaker_config}") + st.write(f"**Segments:** {selected_profile.num_segments}") + st.write(f"**AI Models:** {selected_profile.outline_provider}/{selected_profile.outline_model} (outline), {selected_profile.transcript_provider}/{selected_profile.transcript_model} (transcript)") + + # Show speaker preview + speaker_profile = asyncio.run(SpeakerProfile.get_by_name(selected_profile.speaker_config)) + if speaker_profile: + st.write(f"**Speakers ({len(speaker_profile.speakers)}):**") + for speaker in speaker_profile.speakers: + st.write(f"- **{speaker['name']}**: {speaker['personality']}") + + with st.container(): + st.text_area( + "Default Briefing:", + value=selected_profile.default_briefing, + height=100, + disabled=True + ) + + return selected_name + + return None +``` + +#### 3.2 Create Status Display Component +```python +# pages/components/podcast_status_display.py +import asyncio +import streamlit as st +from typing import List +from datetime import datetime +from open_notebook.domain.podcast import PodcastEpisode +import humanize + +class PodcastStatusDisplay: + """Component for displaying podcast episodes with job status""" + + @staticmethod + async def render(notebook_id: Optional[str] = None): + """Render podcast episodes with status""" + + # Get episodes with job status + episodes = await PodcastStatusDisplay._get_episodes_with_status(notebook_id) + + if not episodes: + st.info("No podcast episodes found. Generate your first episode above!") + return + + st.subheader(f"📻 Podcast Episodes ({len(episodes)})") + + # Group by status for better organization + status_groups = { + "completed": [], + "running": [], + "failed": [], + "pending": [] + } + + for episode in episodes: + status = episode.get("job_status", "unknown") + if status == "completed": + status_groups["completed"].append(episode) + elif status in ["running", "processing"]: + status_groups["running"].append(episode) + elif status == "failed": + status_groups["failed"].append(episode) + else: + status_groups["pending"].append(episode) + + # Display running jobs first + if status_groups["running"]: + st.write("🔄 **Currently Processing**") + for episode in status_groups["running"]: + PodcastStatusDisplay._render_episode_card(episode, show_audio=False) + + # Display completed episodes + if status_groups["completed"]: + st.write("✅ **Completed Episodes**") + for episode in status_groups["completed"]: + PodcastStatusDisplay._render_episode_card(episode, show_audio=True) + + # Display failed jobs + if status_groups["failed"]: + st.write("❌ **Failed Episodes**") + for episode in status_groups["failed"]: + PodcastStatusDisplay._render_episode_card(episode, show_audio=False) + + # Display pending jobs + if status_groups["pending"]: + st.write("⏳ **Pending Episodes**") + for episode in status_groups["pending"]: + PodcastStatusDisplay._render_episode_card(episode, show_audio=False) + + @staticmethod + def _render_episode_card(episode_data: dict, show_audio: bool = True): + """Render individual episode card""" + with st.container(): + st.markdown("---") + + col1, col2, col3 = st.columns([3, 1, 1]) + + with col1: + status_emoji = { + "completed": "✅", + "running": "🔄", + "failed": "❌", + "pending": "⏳" + }.get(episode_data.get("job_status", "unknown"), "❓") + + st.write(f"{status_emoji} **{episode_data['name']}**") + st.caption(f"Profile: {episode_data.get('episode_profile', 'Unknown')}") + + with col2: + if episode_data.get("created"): + created_date = datetime.fromisoformat(episode_data["created"].replace('Z', '+00:00')) + st.caption(f"Created: {humanize.naturaltime(created_date)}") + + with col3: + # Refresh button for non-completed episodes + if episode_data.get("job_status") not in ["completed", "failed"]: + if st.button("🔄", key=f"refresh_{episode_data['id']}", help="Refresh status"): + st.rerun() + + # Show audio player for completed episodes + if show_audio and episode_data.get("audio_file"): + try: + st.audio(episode_data["audio_file"], format="audio/mpeg") + except Exception: + st.error("Audio file not found or corrupted") + + # Show error message for failed episodes + if episode_data.get("job_status") == "failed" and episode_data.get("error_message"): + st.error(f"Error: {episode_data['error_message']}") + + # Show metadata in expander + with st.expander(f"Details - {episode_data['name']}", expanded=False): + metadata = episode_data.get("generation_metadata", {}) + if metadata: + st.json(metadata) + + if episode_data.get("briefing"): + st.text_area( + "Briefing Used:", + value=episode_data["briefing"], + height=100, + disabled=True, + key=f"briefing_{episode_data['id']}" + ) + + @staticmethod + async def _get_episodes_with_status(notebook_id: Optional[str] = None) -> List[dict]: + """Get episodes with their job status""" + from open_notebook.database.repository import repo_query + + # Query episodes with command status + if notebook_id: + query = """ + SELECT *, + command.status AS job_status, + command.error_message AS error_message + FROM podcast_episode + WHERE notebook_id = $notebook_id + ORDER BY created DESC + """ + params = {"notebook_id": notebook_id} + else: + query = """ + SELECT *, + command.status AS job_status, + command.error_message AS error_message + FROM podcast_episode + ORDER BY created DESC + """ + params = {} + + result = await repo_query(query, params) + return result +``` + +#### 3.3 Modernize Main Podcast Page +```python +# pages/5_🎙️_Podcasts.py - Complete rewrite +import asyncio +import streamlit as st +import nest_asyncio +from pages.stream_app.utils import setup_page +from pages.components.episode_profile_selector import EpisodeProfileSelector +from pages.components.podcast_status_display import PodcastStatusDisplay +from api.podcast_service import PodcastService, DefaultProfiles + +nest_asyncio.apply() + +setup_page("🎙️ Podcasts", only_check_mandatory_models=False) + +# Page title and description +st.title("🎙️ Podcast Generator") +st.markdown(""" +Create professional podcasts from your notebook content using AI-powered Episode Profiles. +Choose from pre-configured styles or create custom profiles for your unique podcast format. +""") + +# Initialize default profiles if needed +if st.button("🔧 Initialize Default Profiles", help="Create default episode and speaker profiles"): + with st.spinner("Creating default profiles..."): + try: + asyncio.run(DefaultProfiles.create_default_episode_profiles()) + asyncio.run(DefaultProfiles.create_default_speaker_profiles()) + st.success("✅ Default profiles created successfully!") + except Exception as e: + st.error(f"Failed to create default profiles: {e}") + +st.markdown("---") + +# Main podcast generation section +st.subheader("🎬 Generate New Episode") + +# Check if we have a current notebook +current_notebook_id = st.session_state.get("current_notebook_id") +if not current_notebook_id: + st.warning("⚠️ Please select a notebook first from the main page.") + st.stop() + +col1, col2 = st.columns([2, 1]) + +with col1: + # Episode Profile Selection (3-click workflow starts here) + selected_profile = asyncio.run(EpisodeProfileSelector.render()) + + if selected_profile: + # Episode Name Input + episode_name = st.text_input( + "Episode Name", + placeholder="e.g., Tech Discussion on AI Trends", + help="Choose a descriptive name for your podcast episode" + ) + + # Optional briefing suffix + briefing_suffix = st.text_area( + "Additional Instructions (Optional)", + placeholder="Add specific instructions for this episode...", + height=100, + help="Customize the briefing for this specific episode" + ) + +with col2: + st.markdown("### 📋 Generation Checklist") + st.markdown(f""" + - {'✅' if selected_profile else '⏳'} **Episode Profile**: {selected_profile or 'Not selected'} + - {'✅' if episode_name else '⏳'} **Episode Name**: {'Set' if episode_name else 'Required'} + - {'✅' if current_notebook_id else '❌'} **Notebook Content**: {'Available' if current_notebook_id else 'Missing'} + """) + +# Generate button (3-click workflow completion) +if selected_profile and episode_name and current_notebook_id: + st.markdown("---") + + # Estimated generation time + st.info("⏱️ **Estimated generation time**: 2-3 minutes for professional quality podcast") + + if st.button("🚀 Generate Podcast", type="primary", use_container_width=True): + with st.spinner("🎙️ Starting podcast generation..."): + try: + job_id = asyncio.run(PodcastService.submit_generation_job( + notebook_id=current_notebook_id, + episode_profile_name=selected_profile, + episode_name=episode_name, + briefing_suffix=briefing_suffix if briefing_suffix.strip() else None + )) + + st.success(f""" + ✅ **Podcast generation started!** + + **Job ID**: `{job_id}` + + Your podcast is being generated in the background. You can continue using Open Notebook while it processes. + The episode will appear in the list below when completed. + """) + + # Auto-refresh to show the new job + st.rerun() + + except Exception as e: + st.error(f"❌ Failed to start podcast generation: {e}") + +st.markdown("---") + +# Episodes display section +asyncio.run(PodcastStatusDisplay.render(current_notebook_id)) + +# Footer with helpful information +st.markdown("---") +with st.expander("ℹ️ How it works", expanded=False): + st.markdown(""" + ### 🎯 3-Click Podcast Generation + + 1. **Choose Profile**: Select from pre-configured episode styles + 2. **Name Episode**: Give your podcast a descriptive name + 3. **Generate**: Click generate and continue using Open Notebook + + ### 🎨 Episode Profiles + - **Tech Discussion**: 2 experts discussing technical topics + - **Solo Expert**: Single expert explaining complex concepts + - **Business Analysis**: Business-focused panel discussion + + ### 🔄 Background Processing + - Podcasts generate in the background (2-3 minutes) + - No need to wait - continue your research + - Refresh the page to see updates + + ### 🎧 Professional Quality + - Multiple AI models for outline and transcript generation + - High-quality text-to-speech with personality-rich speakers + - Support for 1-4 speakers (vs Google's 2-speaker limit) + """) +``` + +#### 3.4 Update Chat Integration +```python +# pages/stream_app/chat.py - Update podcast tab (lines 76-132) +with podcast_tab: + st.markdown("### 🎙️ Quick Podcast Generation") + + # Simple profile selector for chat context + episode_profiles = asyncio.run(EpisodeProfile.get_all()) + if episode_profiles: + profile_names = [ep.name for ep in episode_profiles] + selected_template = st.selectbox("Episode Profile", profile_names) + + episode_name = st.text_input("Episode Name", key="chat_episode_name") + + if episode_name and selected_template: + if st.button("🚀 Generate from Chat Context"): + try: + job_id = asyncio.run(PodcastService.submit_generation_job( + notebook_id=current_notebook.id, + episode_profile_name=selected_template, + episode_name=episode_name, + briefing_suffix="Generate podcast from current chat context" + )) + st.success(f"Podcast generation started! Job ID: {job_id}") + except Exception as e: + st.error(f"Failed to generate podcast: {e}") + else: + st.warning("No episode profiles available. Please initialize default profiles.") + + st.page_link("pages/5_🎙️_Podcasts.py", label="🎙️ Go to Full Podcast Interface") +``` + +### ✅ Testing Strategy +1. **Profile Selection**: Test episode profile selection and preview +2. **3-Click Workflow**: Verify simplified generation process +3. **Status Display**: Test job status updates and refresh functionality +4. **Audio Playback**: Verify completed episodes play correctly +5. **Error Handling**: Test UI behavior with failed generations +6. **Chat Integration**: Test quick generation from chat context + +### 🧪 Manual Testing Scenarios +``` +# Test 3-Click Workflow: +1. Navigate to Podcasts page +2. Select "tech_discussion" profile +3. Enter episode name "Test Episode" +4. Click "Generate Podcast" +5. Verify job appears in status list +6. Wait for completion and test audio playback + +# Test Status Updates: +1. Generate multiple episodes +2. Refresh page to see status updates +3. Test failed episode error display +4. Verify completed episodes show audio player + +# Test Profile Management: +1. Initialize default profiles +2. Verify all profiles load correctly +3. Test profile preview information +4. Verify speaker configuration display +``` + +### ⚠️ Critical Notes +- **UI Simplification**: Massive reduction from 15+ fields to 3 clicks +- **Non-blocking UX**: Users can continue working while podcasts generate +- **No Real-time Updates**: Simple refresh-based status (preparing for React migration) +- **Profile Dependencies**: Ensure default profiles are created before first use +- **Audio Storage**: Verify audio files are accessible from Streamlit +- **🛑 STOP**: Request human approval before proceeding to Phase 4 + +--- + +## Phase 4: Data Migration (OSS-141) - 3 hours + +### 🎯 Goals +- Create new database schema for Episode and Speaker profiles +- Migrate existing podcast_config data to new Episode Profile format +- Maintain backward compatibility during transition +- Enable smooth rollback if needed + +### 📁 Files to Create/Change +1. **NEW**: `migrations/7.surrealql` - New schema creation +2. **NEW**: `migrations/7_down.surrealql` - Rollback script +3. **NEW**: `api/migration_service.py` - Data migration utilities +4. **NEW**: `api/routers/migration.py` - Migration management endpoints +5. **MODIFY**: `api/main.py` - Add migration router + +### 🔧 Specific Implementation Steps + +#### 4.1 Create New Database Schema +```sql +-- migrations/7.surrealql +DEFINE TABLE IF NOT EXISTS episode_profile SCHEMAFULL; +DEFINE FIELD IF NOT EXISTS name ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS description ON TABLE episode_profile TYPE option; +DEFINE FIELD IF NOT EXISTS speaker_config ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS outline_provider ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS outline_model ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS transcript_provider ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS transcript_model ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS default_briefing ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS num_segments ON TABLE episode_profile TYPE int DEFAULT 5; +DEFINE FIELD IF NOT EXISTS migrated_from_podcast_config ON TABLE episode_profile TYPE option; +DEFINE FIELD IF NOT EXISTS created ON TABLE episode_profile TYPE datetime DEFAULT time::now(); +DEFINE FIELD IF NOT EXISTS updated ON TABLE episode_profile TYPE datetime DEFAULT time::now(); + +-- Create Speaker Profile table +DEFINE TABLE IF NOT EXISTS speaker_profile SCHEMAFULL; +DEFINE FIELD IF NOT EXISTS name ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS description ON TABLE speaker_profile TYPE option; +DEFINE FIELD IF NOT EXISTS tts_provider ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS tts_model ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS speakers ON TABLE speaker_profile TYPE array; +DEFINE FIELD IF NOT EXISTS migrated_from_podcast_config ON TABLE speaker_profile TYPE option; +DEFINE FIELD IF NOT EXISTS created ON TABLE speaker_profile TYPE datetime DEFAULT time::now(); +DEFINE FIELD IF NOT EXISTS updated ON TABLE speaker_profile TYPE datetime DEFAULT time::now(); + +-- Enhance PodcastEpisode table +DEFINE TABLE IF NOT EXISTS episode SCHEMAFULL; +DEFINE FIELD IF NOT EXISTS episode_profile ON TABLE episode TYPE string; +DEFINE FIELD IF NOT EXISTS generation_metadata ON TABLE episode TYPE object; +DEFINE FIELD IF NOT EXISTS briefing ON TABLE episode TYPE option; +DEFINE FIELD IF NOT EXISTS transcript ON TABLE episode TYPE option; +DEFINE FIELD IF NOT EXISTS outline ON TABLE episode TYPE option; +DEFINE FIELD IF NOT EXISTS command ON TABLE episode TYPE record; + +-- Create indexes for better performance +DEFINE INDEX IF NOT EXISTS idx_episode_profile_name ON TABLE episode_profile COLUMNS name UNIQUE CONCURRENTLY; +DEFINE INDEX IF NOT EXISTS idx_speaker_profile_name ON TABLE speaker_profile COLUMNS name UNIQUE CONCURRENTLY; +DEFINE INDEX IF NOT EXISTS idx_episode_profile ON TABLE episode COLUMNS episode_profile CONCURRENTLY; +DEFINE INDEX IF NOT EXISTS idx_episode_command ON TABLE episode COLUMNS command CONCURRENTLY; + +``` + +#### 4.3 Create Migration Service +```python +# api/migration_service.py +from typing import List, Dict, Any, Optional +from loguru import logger +from open_notebook.database.repository import repo_query, repo_create +from open_notebook.domain.podcast import EpisodeProfile, SpeakerProfile + +class PodcastMigrationService: + """Service for migrating podcast_config data to Episode Profiles""" + + @staticmethod + async def analyze_existing_configs() -> Dict[str, Any]: + """Analyze existing podcast_config records for migration planning""" + try: + configs = await repo_query("SELECT * FROM podcast_config") + + analysis = { + "total_configs": len(configs), + "unique_combinations": {}, + "tts_providers": set(), + "models": set(), + "languages": set(), + "migration_candidates": [] + } + + for config in configs: + # Analyze TTS usage + analysis["tts_providers"].add(config.get("provider", "unknown")) + analysis["models"].add(config.get("model", "unknown")) + analysis["languages"].add(config.get("output_language", "unknown")) + + # Create combination signature for deduplication + combo_key = f"{config.get('provider')}_{config.get('model')}_{len(config.get('person1_role', []))}_{len(config.get('person2_role', []))}" + + if combo_key not in analysis["unique_combinations"]: + analysis["unique_combinations"][combo_key] = { + "count": 0, + "example_config": config, + "suggested_profile_name": PodcastMigrationService._suggest_profile_name(config) + } + + analysis["unique_combinations"][combo_key]["count"] += 1 + + # Add to migration candidates + analysis["migration_candidates"].append({ + "config_id": config.get("id"), + "name": config.get("name"), + "suggested_episode_profile": PodcastMigrationService._suggest_profile_name(config), + "suggested_speaker_profile": PodcastMigrationService._suggest_speaker_profile_name(config) + }) + + # Convert sets to lists for JSON serialization + analysis["tts_providers"] = list(analysis["tts_providers"]) + analysis["models"] = list(analysis["models"]) + analysis["languages"] = list(analysis["languages"]) + + return analysis + + except Exception as e: + logger.error(f"Failed to analyze existing configs: {e}") + raise + + @staticmethod + def _suggest_profile_name(config: Dict[str, Any]) -> str: + """Suggest an episode profile name based on config characteristics""" + person1_roles = config.get("person1_role", []) + person2_roles = config.get("person2_role", []) + + # Determine if it's solo or multi-speaker + if not person2_roles or len(person2_roles) == 0: + return f"solo_{config.get('name', 'custom').lower().replace(' ', '_')}" + + # Look for common role patterns + all_roles = person1_roles + person2_roles + if any("tech" in role.lower() or "engineer" in role.lower() for role in all_roles): + return f"tech_{config.get('name', 'discussion').lower().replace(' ', '_')}" + elif any("business" in role.lower() or "analyst" in role.lower() for role in all_roles): + return f"business_{config.get('name', 'analysis').lower().replace(' ', '_')}" + else: + return f"custom_{config.get('name', 'discussion').lower().replace(' ', '_')}" + + @staticmethod + def _suggest_speaker_profile_name(config: Dict[str, Any]) -> str: + """Suggest a speaker profile name based on config characteristics""" + provider = config.get("provider", "openai") + person2_roles = config.get("person2_role", []) + + if not person2_roles or len(person2_roles) == 0: + return f"solo_{provider}" + else: + return f"dual_{provider}" + + @staticmethod + async def migrate_config_to_profiles(config_id: str) -> Dict[str, str]: + """Migrate a specific podcast_config to Episode and Speaker profiles""" + try: + # Get the config + config_result = await repo_query( + "SELECT * FROM podcast_config WHERE id = $id", + {"id": config_id} + ) + + if not config_result: + raise ValueError(f"Config not found: {config_id}") + + config = config_result[0] + + # Create speaker profile + speaker_profile_name = PodcastMigrationService._suggest_speaker_profile_name(config) + speakers = [] + + # Add first speaker + if config.get("person1_role"): + speakers.append({ + "name": "Speaker 1", + "voice_id": config.get("voice1", "nova"), + "backstory": f"Expert in: {', '.join(config.get('person1_role', []))}", + "personality": f"Role: {', '.join(config.get('person1_role', []))}" + }) + + # Add second speaker if exists + if config.get("person2_role") and len(config.get("person2_role", [])) > 0: + speakers.append({ + "name": "Speaker 2", + "voice_id": config.get("voice2", "alloy"), + "backstory": f"Expert in: {', '.join(config.get('person2_role', []))}", + "personality": f"Role: {', '.join(config.get('person2_role', []))}" + }) + + # Check if speaker profile already exists + existing_speaker = await SpeakerProfile.get_by_name(speaker_profile_name) + if not existing_speaker: + speaker_profile = SpeakerProfile( + name=speaker_profile_name, + description=f"Migrated from podcast_config: {config.get('name')}", + tts_provider=config.get("provider", "openai"), + tts_model=config.get("model", "tts-1"), + speakers=speakers, + migrated_from_podcast_config=config_id + ) + await speaker_profile.save() + + # Create episode profile + episode_profile_name = PodcastMigrationService._suggest_profile_name(config) + + # Build briefing from old fields + briefing_parts = [ + f"Podcast: {config.get('podcast_name', 'Unknown')}", + f"Tagline: {config.get('podcast_tagline', '')}", + f"Language: {config.get('output_language', 'English')}", + ] + + if config.get("conversation_style"): + briefing_parts.append(f"Conversation Style: {', '.join(config.get('conversation_style', []))}") + + if config.get("engagement_technique"): + briefing_parts.append(f"Engagement Techniques: {', '.join(config.get('engagement_technique', []))}") + + if config.get("user_instructions"): + briefing_parts.append(f"Special Instructions: {config.get('user_instructions')}") + + default_briefing = "\n".join(briefing_parts) + + # Determine number of segments from dialogue_structure + num_segments = len(config.get("dialogue_structure", [])) if config.get("dialogue_structure") else 5 + num_segments = max(3, min(10, num_segments)) # Clamp between 3-10 + + # Check if episode profile already exists + existing_episode = await EpisodeProfile.get_by_name(episode_profile_name) + if not existing_episode: + episode_profile = EpisodeProfile( + name=episode_profile_name, + description=f"Migrated from podcast_config: {config.get('name')}", + speaker_config=speaker_profile_name, + outline_provider=config.get("transcript_model_provider", "openai"), + outline_model=config.get("transcript_model", "gpt-4o-mini"), + transcript_provider=config.get("transcript_model_provider", "openai"), + transcript_model=config.get("transcript_model", "gpt-4o-mini"), + default_briefing=default_briefing, + num_segments=num_segments, + migrated_from_podcast_config=config_id + ) + await episode_profile.save() + + return { + "episode_profile": episode_profile_name, + "speaker_profile": speaker_profile_name + } + + except Exception as e: + logger.error(f"Failed to migrate config {config_id}: {e}") + raise + + @staticmethod + async def migrate_all_configs() -> Dict[str, Any]: + """Migrate all podcast_config records to new format""" + try: + configs = await repo_query("SELECT * FROM podcast_config") + + results = { + "total_configs": len(configs), + "migrated": 0, + "failed": 0, + "skipped": 0, + "episode_profiles_created": set(), + "speaker_profiles_created": set(), + "errors": [] + } + + for config in configs: + try: + # Check if already migrated + episode_name = PodcastMigrationService._suggest_profile_name(config) + existing = await EpisodeProfile.get_by_name(episode_name) + + if existing and existing.migrated_from_podcast_config: + results["skipped"] += 1 + continue + + # Migrate the config + profiles = await PodcastMigrationService.migrate_config_to_profiles(config["id"]) + + results["migrated"] += 1 + results["episode_profiles_created"].add(profiles["episode_profile"]) + results["speaker_profiles_created"].add(profiles["speaker_profile"]) + + except Exception as e: + results["failed"] += 1 + results["errors"].append({ + "config_id": config.get("id"), + "config_name": config.get("name"), + "error": str(e) + }) + + # Convert sets to lists for JSON serialization + results["episode_profiles_created"] = list(results["episode_profiles_created"]) + results["speaker_profiles_created"] = list(results["speaker_profiles_created"]) + + return results + + except Exception as e: + logger.error(f"Failed to migrate all configs: {e}") + raise +``` + +#### 4.4 Create Migration Endpoints +```python +# api/routers/migration.py +from fastapi import APIRouter, HTTPException +from typing import Dict, Any +from api.migration_service import PodcastMigrationService +from loguru import logger + +router = APIRouter() + +@router.get("/migration/podcast-analysis") +async def analyze_podcast_configs() -> Dict[str, Any]: + """Analyze existing podcast_config records for migration planning""" + try: + analysis = await PodcastMigrationService.analyze_existing_configs() + return { + "success": True, + "analysis": analysis + } + except Exception as e: + logger.error(f"Failed to analyze podcast configs: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to analyze podcast configurations: {str(e)}" + ) + +@router.post("/migration/podcast-config/{config_id}") +async def migrate_specific_config(config_id: str) -> Dict[str, Any]: + """Migrate a specific podcast_config to Episode and Speaker profiles""" + try: + profiles = await PodcastMigrationService.migrate_config_to_profiles(config_id) + return { + "success": True, + "message": f"Successfully migrated config {config_id}", + "profiles": profiles + } + except Exception as e: + logger.error(f"Failed to migrate config {config_id}: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to migrate configuration: {str(e)}" + ) + +@router.post("/migration/podcast-configs/all") +async def migrate_all_configs() -> Dict[str, Any]: + """Migrate all podcast_config records to Episode and Speaker profiles""" + try: + results = await PodcastMigrationService.migrate_all_configs() + return { + "success": True, + "message": "Migration completed", + "results": results + } + except Exception as e: + logger.error(f"Failed to migrate all configs: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to migrate all configurations: {str(e)}" + ) + +@router.get("/migration/status") +async def get_migration_status() -> Dict[str, Any]: + """Get current migration status""" + try: + from open_notebook.database.repository import repo_query + + # Check migration version + version_result = await repo_query("SELECT * FROM open_notebook:migration_version") + current_version = version_result[0]["version"] if version_result else 0 + + # Count records + configs = await repo_query("SELECT count() as count FROM podcast_config") + episode_profiles = await repo_query("SELECT count() as count FROM episode_profile") + speaker_profiles = await repo_query("SELECT count() as count FROM speaker_profile") + + return { + "migration_version": current_version, + "schema_ready": current_version >= 7, + "podcast_configs": configs[0]["count"] if configs else 0, + "episode_profiles": episode_profiles[0]["count"] if episode_profiles else 0, + "speaker_profiles": speaker_profiles[0]["count"] if speaker_profiles else 0 + } + except Exception as e: + logger.error(f"Failed to get migration status: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to get migration status: {str(e)}" + ) +``` + +### ✅ Testing Strategy +1. **Schema Creation**: Verify new tables are created correctly +2. **Migration Analysis**: Test analysis of existing podcast_config records +3. **Single Migration**: Test migrating one podcast_config successfully +4. **Bulk Migration**: Test migrating all configs with error handling +5. **Rollback**: Verify rollback script works correctly +6. **Data Integrity**: Ensure migrated profiles work with podcast generation + +### 🧪 Manual Testing Commands +```bash +# 1. Check migration status +curl "http://localhost:5055/api/migration/status" + +# 2. Analyze existing configs +curl "http://localhost:5055/api/migration/podcast-analysis" + +# 3. Migrate specific config +curl -X POST "http://localhost:5055/api/migration/podcast-config/{config_id}" + +# 4. Migrate all configs +curl -X POST "http://localhost:5055/api/migration/podcast-configs/all" + +# 5. Verify new profiles work +curl "http://localhost:5055/api/episode-profiles" +curl "http://localhost:5055/api/speaker-profiles" + +# 6. Test generation with migrated profile +curl -X POST "http://localhost:5055/api/podcasts/generate" \ + -H "Content-Type: application/json" \ + -d '{ + "notebook_id": "test_notebook", + "episode_profile_name": "migrated_profile_name", + "episode_name": "migration_test" + }' +``` + +### ⚠️ Critical Notes +- **Data Preservation**: All existing podcast_config data is preserved +- **Backward Compatibility**: Old configs remain accessible during transition +- **Migration Tracking**: All profiles track their migration source +- **Rollback Safety**: Complete rollback script available if needed +- **Validation Required**: Test migrated profiles generate podcasts correctly +- **🛑 COMPLETE**: Epic implementation finished - request final review + +--- + +## 📋 Implementation Summary & Progress Tracking + +### Phase Completion Status +- [x] **Phase 1**: Async Foundation (OSS-137) - ✅ COMPLETED (4 hours actual) +- [ ] **Phase 2**: Engine Integration (OSS-138) - 4 hours estimated +- [ ] **Phase 3**: UI Modernization (OSS-139) - 3 hours estimated +- [ ] **Phase 4**: Data Migration (OSS-141) - 3 hours estimated + +### Session Tracking Template + +```markdown +## Session [Date] - Phase [N] Progress + +### Completed Tasks +- [ ] Task 1 +- [ ] Task 2 + +### Testing Results +- [ ] Test scenario 1 +- [ ] Test scenario 2 + +### Issues Encountered +- Issue description and resolution + +### Next Session Plan +- What to tackle next +- Any blockers to address + +### Human Approval Required +- [ ] Phase completion review +- [ ] Ready to proceed to next phase +``` + +### Key Success Metrics +- [x] **Async Foundation**: Background job processing working ✅ COMPLETED +- [x ] **Episode Profiles**: 3-click workflow operational ✅ COMPLETED PHASE 2 +- [ ] **Professional Quality**: 2-3 minute generation time achieved +- [ ] **Competitive Advantage**: 1-4 speaker flexibility vs Google's 2-host limit +- [ ] **User Experience**: Non-blocking UI with status tracking +- [ ] **Data Migration**: All existing configs successfully migrated + +### Final Deliverables +1. ✅ **Async Job Processing**: Surreal-commands integration ✅ COMPLETED PHASE 1 +2. ✅ **Podcast Engine**: Podcast-creator with Episode Profiles ✅ COMPLETED PHASE 2 +3. ⏳ **Simplified UI**: 3-click generation workflow +4. ⏳ **Professional Audio**: High-quality multi-speaker podcasts +5. ⏳ **Status Tracking**: Job monitoring without real-time updates +6. ⏳ **Data Migration**: Seamless transition from old system +7. ⏳ **Competitive Positioning**: Superior flexibility vs Google Notebook LM + + +--- + +**Total Epic Scope**: Professional podcast engine establishing Open Notebook as a superior alternative to Google Notebook LM with flexible speaker options, model choice, and 3-click user experience. \ No newline at end of file diff --git a/.claude/sessions/oss-136/test.md b/.claude/sessions/oss-136/test.md new file mode 100644 index 0000000..ec7ae16 --- /dev/null +++ b/.claude/sessions/oss-136/test.md @@ -0,0 +1,5 @@ +todo: + +- Testar o migration completamente +- Testar muito o Surreal Commands +- Mudar a documentação de como rodar o produto, usando make por conta dos serviços \ No newline at end of file diff --git a/.claude/sessions/podcast_page/architecture.md b/.claude/sessions/podcast_page/architecture.md new file mode 100644 index 0000000..7423ea1 --- /dev/null +++ b/.claude/sessions/podcast_page/architecture.md @@ -0,0 +1,321 @@ +# Podcast Page UX Redesign - Architecture Document + +## 🏗️ **High-Level System Overview** + +### **Before (Current State)** +``` +┌─────────────────────────────────────────┐ +│ Podcast Page │ +├─────────────────────────────────────────┤ +│ ┌─────────────────┐ ┌─────────────────┐ │ +│ │ Tab: Episodes │ │ Tab: Speakers │ │ +│ │ • Episode List │ │ • Complex forms │ │ +│ │ • Status │ │ • Session state │ │ +│ │ • Audio Player │ │ • Inline edit │ │ +│ └─────────────────┘ └─────────────────┘ │ +│ ┌─────────────────┐ │ +│ │ Tab: Ep Profiles│ │ +│ │ • Dropdown deps │ │ +│ │ • Complex forms │ │ +│ └─────────────────┘ │ +└─────────────────────────────────────────┘ +``` + +### **After (Target State)** +``` +┌─────────────────────────────────────────┐ +│ Podcast Page │ +├─────────────────────────────────────────┤ +│ ┌─────────────────┐ ┌─────────────────┐ │ +│ │ Tab: Episodes │ │Tab: Templates │ │ +│ │ • Episode List │ │ ┌─────────────┐ │ │ +│ │ • Status │ │ │ Header │ │ │ +│ │ • Audio Player │ │ │ Explanation │ │ │ +│ │ (unchanged) │ │ └─────────────┘ │ │ +│ └─────────────────┘ │ ┌───────┐┌────┐ │ │ +│ │ │Episode││Spk │ │ │ +│ │ │Profile││Pro │ │ │ +│ │ │ Area ││Side│ │ │ +│ │ │ ││bar │ │ │ +│ │ └───────┘└────┘ │ │ +│ └─────────────────┘ │ +└─────────────────────────────────────────┘ + ↕ st.dialog +┌─────────────────────────────────────────┐ +│ Speaker Configuration │ +│ • Create/Edit Form │ +│ • Dynamic speaker count │ +│ • Model selection │ +└─────────────────────────────────────────┘ +``` + +## 🔧 **Affected Components and Dependencies** + +### **Primary File to Modify** +- `pages/5_🎙️_Podcasts.py` - Complete restructure with new layout + +### **External Dependencies (No Changes)** +- `api/routers/speaker_profiles.py` - Existing CRUD endpoints +- `api/routers/episode_profiles.py` - Existing CRUD endpoints +- `open_notebook/domain/podcast.py` - Data models and validation +- `api/models_service.py` - Model provider/type management + +### **Session State Dependencies** +- Current session state keys that will be modified/removed +- New session state structure for dialog management + +## 📱 **New Component Structure** + +### **Main Layout Components** + +```python +def render_podcast_page(): + """Main page orchestrator""" + episodes_tab, templates_tab = st.tabs(["Episodes", "Templates"]) + + with episodes_tab: + render_episodes_section() # Keep existing functionality + + with templates_tab: + render_header_section() + col_main, col_side = st.columns([3, 1]) + with col_main: + render_episode_profiles_section() + with col_side: + render_speaker_profiles_sidebar() + +def render_episodes_section(): + """Episodes list - keep existing functionality unchanged""" + +def render_header_section(): + """Explanatory header about relationships and workflow""" + +def render_episode_profiles_section(): + """Main focus: Episode profiles CRUD with inline speaker info""" + +def render_speaker_profiles_sidebar(): + """Secondary: Speaker profiles overview with usage indicators""" +``` + +### **Dialog Components** + +```python +@st.dialog("Configure Speaker Profile", width="large") +def speaker_configuration_dialog(mode="create", profile_id=None, episode_context=None): + """Unified dialog for speaker profile create/edit""" + # Mode: "create" | "edit" | "select_for_episode" + +@st.dialog("Confirm Delete") +def confirm_delete_dialog(item_type, item_id, item_name): + """Reusable confirmation dialog""" +``` + +### **Data Flow Architecture** + +```mermaid +graph TD + A[User Action] --> B{Action Type} + + B -->|Episode CRUD| C[Episode API Calls] + B -->|Speaker Select| D[Open Speaker Dialog] + B -->|Speaker CRUD| E[Speaker API Calls] + + D --> F{Dialog Mode} + F -->|Create New| G[Speaker Create Form] + F -->|Edit Existing| H[Speaker Edit Form] + F -->|Select Existing| I[Speaker Dropdown] + + G --> J[API Create Speaker] + H --> K[API Update Speaker] + I --> L[Update Episode Reference] + + C --> M[Refresh Episode Data] + E --> N[Refresh Speaker Data] + J --> N + K --> N + L --> M + + M --> O[Update UI State] + N --> O +``` + +## 🔄 **Session State Management Strategy** + +### **Current Session State (To Remove)** +```python +# Complex nested speaker editing states +st.session_state.new_speakers = [...] +st.session_state.edit_speakers_{profile_id} = [...] +st.session_state.edit_speaker_{profile_id} = True/False +st.session_state.edit_episode_{profile_id} = True/False +``` + +### **New Session State (Simplified)** +```python +# Dialog state management +st.session_state.dialog_mode = "create" | "edit" | "select" +st.session_state.dialog_target_id = profile_id | None +st.session_state.episode_context = episode_id | None # When selecting speaker for episode + +# Temporary form data (only while dialog open) +st.session_state.dialog_speakers = [...] # Cleared on dialog close +st.session_state.dialog_form_data = {...} # Cleared on dialog close + +# Data refresh triggers +st.session_state.refresh_speakers = False +st.session_state.refresh_episodes = False +``` + +### **Session State Lifecycle** +1. **Dialog Open**: Initialize temp form data +2. **Dialog Interaction**: Update temp data only +3. **Dialog Submit**: API call + clear temp data + trigger refresh +4. **Dialog Cancel**: Clear temp data only + +## 🎨 **UI/UX Patterns** + +### **Episode Profile Display** +```python +def episode_profile_card(profile, speakers_data): + with st.container(border=True): + col_info, col_actions = st.columns([3, 1]) + + with col_info: + st.subheader(profile.name) + st.write(profile.description) + render_speaker_info_inline(profile.speaker_config, speakers_data) + render_ai_models_info(profile) + + with col_actions: + if st.button("⚙️ Configure Speaker"): + open_speaker_dialog("select", episode_context=profile.id) + if st.button("✏️ Edit"): + open_episode_edit_form(profile.id) + if st.button("🗑️ Delete"): + confirm_delete_dialog("episode", profile.id, profile.name) +``` + +### **Speaker Profile Sidebar** +```python +def speaker_profiles_sidebar(): + st.subheader("🎤 Speaker Profiles") + + if st.button("➕ New Speaker Profile"): + speaker_configuration_dialog("create") + + for profile in speaker_profiles: + usage_indicator = get_usage_indicator(profile.name) + + with st.expander(f"🎤 {profile.name} {usage_indicator}"): + render_speaker_summary(profile) + + col1, col2, col3 = st.columns(3) + with col1: + if st.button("✏️", key=f"edit_sp_{profile.id}"): + speaker_configuration_dialog("edit", profile.id) + with col2: + if st.button("📋", key=f"dup_sp_{profile.id}"): + duplicate_speaker_profile(profile.id) + with col3: + if st.button("🗑️", key=f"del_sp_{profile.id}"): + confirm_delete_dialog("speaker", profile.id, profile.name) +``` + +## 🔒 **Data Validation and Constraints** + +### **Maintained Validation Rules** +- Speaker profiles: 1-4 speakers, all required fields +- Episode profiles: Valid speaker_config reference, valid AI models +- Names must be unique within profile type +- All existing domain model validators preserved + +### **New Validation Requirements** +- Speaker profile usage checking before deletion +- Episode profile validation when speaker config changes +- Dialog form validation before submission + +## ⚡ **Performance Considerations** + +### **Optimizations** +- **Lazy Loading**: Load speaker details only when needed for episode display +- **Data Caching**: Cache speakers data for episode profile rendering +- **Minimal Re-renders**: Update only affected sections, not entire page +- **Dialog Isolation**: Dialog state doesn't trigger main page re-renders + +### **API Call Patterns** +```python +# Efficient data loading +async def load_page_data(): + speakers, episodes = await asyncio.gather( + fetch_speaker_profiles(), + fetch_episode_profiles() + ) + return speakers, episodes + +# Speaker usage analysis +def analyze_speaker_usage(speakers, episodes): + usage_map = {} + for episode in episodes: + speaker_name = episode.speaker_config + usage_map[speaker_name] = usage_map.get(speaker_name, 0) + 1 + return usage_map +``` + +## 🚀 **Implementation Trade-offs** + +### **Positive Consequences** +- **Better UX**: Single page workflow eliminates confusion +- **Faster Workflow**: Inline creation via dialogs +- **Clearer Relationships**: Visual indicators show usage +- **Maintainable Code**: Simplified session state management + +### **Negative Consequences** +- **Code Reorganization**: Large refactor of existing file +- **Dialog Complexity**: More complex dialog state management +- **Screen Real Estate**: Less space per profile in sidebar +- **Migration Effort**: Users need to learn new interface + +### **Alternative Approaches Considered** +1. **Keep tabs, improve explanations**: Lower impact but doesn't solve core UX issue +2. **Separate pages with better navigation**: Still requires multiple page loads +3. **Wizard-style workflow**: Too rigid for power users + +## 📋 **Implementation Priority** + +### **Phase 1: Core Structure** +1. Create new layout with header/main/sidebar +2. Move episode profiles to main area +3. Move speaker profiles to sidebar (read-only) + +### **Phase 2: Dialog Integration** +1. Implement speaker configuration dialog +2. Add create/edit/select modes +3. Integrate with episode profile workflow + +### **Phase 3: Polish & Optimization** +1. Add usage indicators +2. Optimize data loading +3. Add better validation feedback +4. Polish animations and interactions + +## 📁 **Files to Edit/Create** + +### **Primary Modification** +- `pages/5_🎙️_Podcasts.py` - Complete rewrite (~900 lines → ~600 lines) + +### **No Changes Required** +- API routers and services (well-designed, reusable) +- Domain models (validation rules preserved) +- Database schema (no data migration needed) + +### **Validation Notes** +- All existing API endpoints remain unchanged +- All existing data models and validation preserved +- Migration path: gradual rollout possible by feature flag +- Backward compatibility: API contracts unchanged + +--- + +**Architecture Ready for Implementation** ✅ + +This architecture maintains all existing functionality while dramatically improving the user experience through better information architecture and progressive disclosure patterns. \ No newline at end of file diff --git a/.claude/sessions/podcast_page/context.md b/.claude/sessions/podcast_page/context.md new file mode 100644 index 0000000..b005360 --- /dev/null +++ b/.claude/sessions/podcast_page/context.md @@ -0,0 +1,74 @@ +# Podcast Page UX Redesign - Context Document + +## 🎯 **Why This is Being Built** + +The current Podcast page has a confusing 3-tab interface (Episodes, Speaker Profiles, Episode Profiles) that makes users unclear about the relationship between speaker profiles and episode profiles. Users don't understand they need to create speaker profiles before episode profiles, leading to workflow confusion. + +## 🎁 **Expected Outcome** + +A streamlined 2-tab Podcast page: +1. **Episodes Tab**: Lists generated episodes (unchanged) +2. **Episode Templates Tab**: Combined episode profiles + speaker profiles management in a single interface that guides users naturally through the creation workflow. + +## 🏗️ **How It Should Be Built** + +### **Page Layout** +- **Header Section**: Explanatory paragraph about how episode profiles depend on speaker profiles and the creation workflow +- **Tab 1: Episodes**: List generated podcast episodes (keep current functionality) +- **Tab 2: Episode Templates**: Combined episode profiles + speaker profiles management + - **Main Area**: Episode profiles management (primary focus) + - **Side Column**: Speaker profiles overview/management (secondary) + - **Dialogs**: Speaker profile creation/editing using `st.dialog` + +### **Dialog Strategy** +- **"Configure Speaker" button** in episode profile → Dialog with dropdown of existing speakers + "Create New" option +- **"Create New Speaker"** → Full speaker creation form within dialog +- **"Edit Speaker"** → Pre-populated form (same as create, just with existing data) + +### **Speaker Profiles Column** +- Show all speaker profiles with usage indicators (highlight which ones are referenced by episode profiles) +- Provide duplicate, edit, delete actions via buttons +- Edit/create actions open dialogs (no inline forms) + +### **Speaker Profile Information Display** +- Show speaker details directly within episode profile containers +- No separate "view-only" dialog needed - display info inline + +## 🔧 **Testing Approach** + +- Test creation workflow: create speaker profile → create episode profile that references it +- Test inline workflow: create episode profile → create speaker profile via dialog when needed +- Test editing flows for both profile types +- Verify speaker profile usage indicators work correctly +- Test all dialog interactions and form validations + +## 📚 **Dependencies** + +- Current API endpoints for speaker profiles and episode profiles (already implemented) +- Streamlit `st.dialog` functionality +- Existing validation logic in domain models +- Current Streamlit form components and session state management + +## 🚧 **Constraints** + +- Must maintain existing data models and API contracts +- Must preserve all current functionality (CRUD operations) +- Use existing validation rules from domain models +- Keep current API service pattern for data operations + +## 🎨 **UI/UX Principles** + +- **Primary focus**: Episode profiles (main content area) +- **Secondary support**: Speaker profiles (side column) +- **Progressive disclosure**: Use dialogs for complex forms +- **Context awareness**: Show relevant information at the right time +- **Clear hierarchy**: Guide users through the natural workflow + +## 📝 **Header Explanation Content** + +The header should explain: +- Episode profiles define the format and AI models for podcast generation +- Speaker profiles define the voices and personalities that will be used +- Episode profiles reference speaker profiles by name +- Recommended workflow: Create speaker profiles first, then episode profiles that use them +- Alternative: Create episode profiles and add speaker profiles on-demand via dialogs \ No newline at end of file diff --git a/.claude/sessions/podcast_page/plan.md b/.claude/sessions/podcast_page/plan.md new file mode 100644 index 0000000..28534a9 --- /dev/null +++ b/.claude/sessions/podcast_page/plan.md @@ -0,0 +1,398 @@ +# Podcast Page UX Redesign Implementation Plan + +If you are working on this feature, make sure to update this plan.md file as you go. + +## PHASE 1: Foundation & Tab Restructure [✅ COMPLETED] + +Restructure the page from 3 tabs to 2 tabs: Episodes (unchanged) and Templates (combined episode profiles + speaker profiles). + +### Rename tabs and restructure layout [✅ COMPLETED] + +- ✅ Changed from 3 tabs (`Episodes`, `Speaker Profiles`, `Episode Profiles`) to 2 tabs (`Episodes`, `Templates`) +- ✅ Kept Episodes tab content exactly as it is (no changes to episodes display) +- ✅ Created new Templates tab structure with header section + main/sidebar layout +- ✅ Verified Episodes tab still works correctly unchanged + +**Time Estimate**: 45 minutes → **Actual**: 30 minutes +**Dependencies**: None +**Testing**: ✅ Episodes tab unchanged, Templates tab has proper layout structure + +### Create Templates tab header section [✅ COMPLETED] + +- ✅ Added explanatory header content about episode profiles and speaker profiles relationship +- ✅ Included workflow guidance explaining the dependency relationship +- ✅ Added tip about creating speaker profiles on-demand via dialog +- ✅ Styled header to be informative but not overwhelming + +**Time Estimate**: 30 minutes → **Actual**: 20 minutes +**Dependencies**: Tab structure completed +**Testing**: ✅ Header content displays correctly and provides clear guidance + +### Setup Templates tab layout with placeholder content [✅ COMPLETED] + +- ✅ Created main area (3/4 width) and sidebar (1/4 width) using `st.columns([3, 1])` +- ✅ Added placeholder content in main area: "Episode Profiles - Coming in Phase 3" +- ✅ Added placeholder content in sidebar: "Speaker Profiles - Coming in Phase 2" +- ✅ Layout is responsive and visually balanced + +**Time Estimate**: 45 minutes → **Actual**: 25 minutes +**Dependencies**: Header section completed +**Testing**: ✅ Layout is responsive and visually balanced + +### Implementation Notes: +- ✅ Successfully restructured to 2-tab layout +- ✅ Episodes tab functionality preserved completely (zero regression risk) +- ✅ Templates tab provides clear guidance and proper layout structure +- ✅ Old tab content disabled with `if False:` block for future migration +- ✅ All linting issues identified but not addressed per user preference to focus on functionality + +### Next Phase Ready: Phase 2 can now begin (Speaker Profiles Sidebar migration) + +## PHASE 2: Speaker Profiles Sidebar [✅ COMPLETED] + +Migrate speaker profiles from the old Speaker Profiles tab to the Templates tab sidebar. + +### Move speaker profiles display to sidebar [✅ COMPLETED] + +- ✅ Extracted speaker profile display logic from old `speaker_profiles_tab` +- ✅ Implemented `render_speaker_profiles_sidebar()` function +- ✅ Display speaker profiles in sidebar using compact expanders +- ✅ Removed complex inline editing forms from sidebar (prepared for dialog migration) +- ✅ Added basic speaker profile information display only + +**Time Estimate**: 1 hour → **Actual**: 45 minutes +**Dependencies**: Phase 1 completed +**Testing**: ✅ Speaker profiles display correctly in sidebar, no inline editing + +### Implement usage indicators [✅ COMPLETED] + +- ✅ Created `analyze_speaker_usage()` function to map episode profiles → speaker relationships +- ✅ Added visual indicators next to speaker profile names (✅ Used (count), ⭕ Unused) +- ✅ Display usage count information in speaker profile expanders +- ✅ Optimized data loading for speakers and episodes + +**Time Estimate**: 45 minutes → **Actual**: 30 minutes +**Dependencies**: Speaker sidebar display completed +**Testing**: ✅ Usage indicators correctly reflect episode profile references + +### Add action buttons with placeholder functionality [✅ COMPLETED] + +- ✅ Added ✏️ Edit, 📋 Duplicate, 🗑️ Delete buttons to speaker profiles in sidebar +- ✅ Buttons show "Coming in Phase 6" messages when clicked (temporary) +- ✅ Button layout is consistent and doesn't overcrowd sidebar +- ✅ Added "➕ New Speaker Profile" button at top of sidebar + +**Time Estimate**: 15 minutes → **Actual**: 15 minutes +**Dependencies**: Usage indicators completed +**Testing**: ✅ Buttons display correctly and show placeholder messages + +### Implementation Notes: +- ✅ Successfully migrated speaker profiles to sidebar with compact display +- ✅ Usage analysis working correctly - shows which speakers are used by episodes +- ✅ Sidebar layout optimized for space constraints with summary info only +- ✅ Action buttons prepared for future dialog integration +- ✅ "New Speaker Profile" button added for future Phase 4 integration + +### Next Phase Ready: Phase 3 can now begin (Episode Profiles Main Area migration) + +## PHASE 3: Episode Profiles Main Area [✅ COMPLETED] + +Migrate episode profiles from the old Episode Profiles tab to the Templates tab main area. + +### Move episode profiles to main area [✅ COMPLETED] + +- ✅ Extracted episode profile logic from old `episode_profiles_tab` +- ✅ Implemented `render_episode_profiles_section()` function +- ✅ Moved episode profiles display and creation forms to Templates tab main area +- ✅ Redesigned episode profile cards to work better in the new layout +- ✅ Added "Create New Episode Profile" section at top of main area + +**Time Estimate**: 1 hour → **Actual**: 1 hour +**Dependencies**: Phase 2 completed +**Testing**: ✅ Episode profiles display and create/edit correctly in main area + +### Add inline speaker information display [✅ COMPLETED] + +- ✅ Created `render_speaker_info_inline()` function +- ✅ Display speaker details within episode profile cards (names, voice IDs, TTS settings) +- ✅ Handle cases where referenced speaker profile doesn't exist (show warning/error) +- ✅ Made speaker information clearly visible but not overwhelming + +**Time Estimate**: 45 minutes → **Actual**: 30 minutes +**Dependencies**: Episode profiles main area completed +**Testing**: ✅ Speaker info displays correctly inline with episode profiles + +### Add placeholder speaker configuration button [✅ COMPLETED] + +- ✅ Added "⚙️ Configure Speaker" button to episode profile cards +- ✅ Button shows "Coming in Phase 5" message when clicked (temporary) +- ✅ Button styling matches overall design and is easily discoverable +- ✅ Button positioned logically within episode profile card layout + +**Time Estimate**: 15 minutes → **Actual**: 15 minutes +**Dependencies**: Inline speaker display completed +**Testing**: ✅ Button displays correctly and shows placeholder message + +### Implementation Notes: +- ✅ Successfully migrated all episode profile functionality to main area +- ✅ Inline speaker information shows clear relationship between profiles +- ✅ Improved card layout with info (3/4) and actions (1/4) columns +- ✅ Error handling for missing speaker profiles with clear warnings +- ✅ Full CRUD functionality preserved (create, read, edit, delete, duplicate) +- ✅ "Configure Speaker" button prepared for Phase 5 dialog integration + +### Next Phase Ready: Phase 4 can now begin (Speaker Configuration Dialog implementation) + +## PHASE 4: Speaker Configuration Dialog [✅ COMPLETED] + +Implement the unified speaker configuration dialog for create/edit operations. + +### Create base dialog structure [✅ COMPLETED] + +- ✅ Implemented `@st.dialog("Configure Speaker Profile", width="large")` +- ✅ Created dialog mode handling: "create", "edit", "select" +- ✅ Setup session state management: `dialog_speakers`, `dialog_name`, etc. +- ✅ Added dialog open/close logic with proper session state cleanup + +**Time Estimate**: 45 minutes → **Actual**: 40 minutes +**Dependencies**: Phase 3 completed +**Testing**: ✅ Dialog opens/closes correctly, session state managed properly + +### Implement create mode [✅ COMPLETED] + +- ✅ Built speaker creation form within dialog (TTS provider/model selection) +- ✅ Added dynamic speaker count functionality (1-4 speakers) with add/remove buttons +- ✅ Implemented form validation and API integration for creating speaker profiles +- ✅ Handle success/error states and refresh sidebar after creation + +**Time Estimate**: 1 hour → **Actual**: 45 minutes +**Dependencies**: Base dialog structure completed +**Testing**: ✅ Can create new speaker profiles via dialog + +### Implement edit mode [✅ COMPLETED] + +- ✅ Pre-populate dialog form with existing speaker profile data +- ✅ Reused create mode form components with populated values +- ✅ Handle update API calls instead of create calls +- ✅ Ensured proper session state cleanup after successful edit + +**Time Estimate**: 15 minutes → **Actual**: 20 minutes +**Dependencies**: Create mode completed +**Testing**: ✅ Can edit existing speaker profiles via dialog + +### Implementation Notes: +- ✅ Unified dialog handles both create and edit modes seamlessly +- ✅ Smart session state management with automatic cleanup +- ✅ Connected sidebar buttons to dialog functionality (create/edit/duplicate/delete) +- ✅ Dynamic speaker form with add/remove functionality works perfectly +- ✅ Form validation ensures data integrity before API calls +- ✅ Success/error handling with user feedback and automatic refresh + +### Next Phase Ready: Phase 5 can now begin (Episode-Speaker Integration with select mode) + +## PHASE 5: Episode-Speaker Integration [✅ COMPLETED] + +Integrate speaker configuration with episode profiles and implement dialog select mode. + +### Implement dialog select mode [✅ COMPLETED] + +- ✅ Added "select" mode to speaker configuration dialog +- ✅ Show dropdown of existing speaker profiles when in select mode +- ✅ Added "Create New Speaker" option within select mode that switches to create mode +- ✅ Handle episode context when dialog opened from "Configure Speaker" button + +**Time Estimate**: 45 minutes → **Actual**: 50 minutes +**Dependencies**: Phase 4 completed +**Testing**: ✅ Can select/assign speaker profiles to episodes via dialog + +### Connect Configure Speaker button [✅ COMPLETED] + +- ✅ Wired up "⚙️ Configure Speaker" buttons in episode profile cards +- ✅ Open dialog in select mode with proper episode context +- ✅ Update episode profile speaker_config when selection is made via API +- ✅ Refresh episode profile display after speaker assignment + +**Time Estimate**: 30 minutes → **Actual**: 20 minutes +**Dependencies**: Select mode implemented +**Testing**: ✅ Episode speaker configuration works end-to-end + +### Add on-demand speaker creation workflow [✅ COMPLETED] + +- ✅ Enabled "Create New Speaker" option in select mode dialog +- ✅ Allow seamless switching from select → create → auto-assign workflow +- ✅ Auto-assign newly created speaker to episode profile +- ✅ Provide smooth user experience for the complete workflow + +**Time Estimate**: 45 minutes → **Actual**: 35 minutes +**Dependencies**: Configure Speaker button connected +**Testing**: ✅ Can create speaker and assign to episode in single workflow + +### Implementation Notes: +- ✅ **Complete workflow integration**: Episode ↔ Speaker relationship management is seamless +- ✅ **Smart mode switching**: Dialog intelligently switches from select → create with context preservation +- ✅ **Auto-assignment**: Newly created speakers automatically assigned to requesting episode +- ✅ **Preview functionality**: Selected speakers show full details before assignment +- ✅ **Context awareness**: Dialog shows which episode is being configured +- ✅ **Error handling**: Graceful handling of missing speakers and failed assignments + +### Next Phase Ready: Phase 6 can now begin (Final speaker profile actions and cleanup) + +## PHASE 6: Speaker Profile Actions [✅ COMPLETED] + +Implement the remaining speaker profile actions (edit, duplicate, delete) from sidebar buttons. + +### Connect edit buttons to dialog [✅ COMPLETED] + +- ✅ Wired up ✏️ Edit buttons in sidebar to open dialog in edit mode +- ✅ Proper profile ID passing and form population working +- ✅ Edit workflow from sidebar works seamlessly +- ✅ All old inline editing code removed + +**Time Estimate**: 30 minutes → **Actual**: Already implemented in Phase 4 +**Dependencies**: Phase 5 completed +**Testing**: ✅ Can edit speaker profiles from sidebar successfully + +### Implement duplicate functionality [✅ COMPLETED] + +- ✅ Connected 📋 Duplicate buttons to duplicate API endpoint +- ✅ Automatic name handling by API (backend generates appropriate names) +- ✅ Sidebar refreshes after successful duplication +- ✅ Errors handled gracefully with user feedback + +**Time Estimate**: 30 minutes → **Actual**: Already implemented in Phase 4 +**Dependencies**: Edit functionality completed +**Testing**: ✅ Can duplicate speaker profiles successfully + +### Implement delete with usage validation [✅ COMPLETED] + +- ✅ Enhanced confirmation dialog with usage checking +- ✅ Prevents deletion if speaker is used by episode profiles +- ✅ Shows detailed warning with list of using episodes +- ✅ Ensures data integrity with clear user guidance + +**Time Estimate**: 45 minutes → **Actual**: 25 minutes +**Dependencies**: Duplicate functionality completed +**Testing**: ✅ Delete validation works correctly, prevents data integrity issues + +### Remove old tab content [✅ COMPLETED] + +- ✅ Removed all old disabled `if False:` content blocks +- ✅ Cleaned up unused session state variables +- ✅ No dead code or broken references remain +- ✅ File reduced from ~1200 lines to ~1060 lines + +**Time Estimate**: 15 minutes → **Actual**: 10 minutes +**Dependencies**: All functionality migrated +**Testing**: ✅ No errors after old code removal, all features work + +### Implementation Notes: +- ✅ **Data Integrity**: Delete validation prevents orphaned references +- ✅ **User Guidance**: Clear instructions when deletion is blocked +- ✅ **Clean Codebase**: Removed all legacy code and comments +- ✅ **Full Functionality**: All CRUD operations working seamlessly +- ✅ **Error Handling**: Comprehensive validation and user feedback + +--- + +# 🎉 PROJECT COMPLETE! + +## Summary: Podcast Page UX Redesign Implementation + +**All 6 phases completed successfully!** The Podcast Page UX redesign has been fully implemented, completely solving the original user confusion about episode profiles and speaker profiles. + +### ✅ **Major Achievements:** + +1. **🎯 Core UX Problem Solved**: Eliminated confusion between episode/speaker profiles +2. **📱 Streamlined Interface**: 3 tabs → 2 tabs with integrated Templates tab +3. **🔗 Clear Relationships**: Inline speaker info shows profile dependencies +4. **⚡ Flexible Workflow**: Create speakers first OR on-demand via dialogs +5. **💫 Smart Features**: Usage indicators, auto-assignment, context awareness +6. **🛡️ Data Integrity**: Usage validation prevents orphaned references + +### ✅ **Implementation Quality:** +- **Zero Regression**: Episodes tab completely unchanged +- **Production Ready**: Full error handling and validation +- **Clean Architecture**: Well-structured functions and session state management +- **User-Friendly**: Progressive disclosure via dialogs +- **Performance Optimized**: Efficient data loading and state management + +### ✅ **Total Time: ~8.5 hours** (vs 12 hour estimate) +- Phase 1: 1.25 hours (Foundation) +- Phase 2: 1.5 hours (Speaker Sidebar) +- Phase 3: 1.75 hours (Episode Main Area) +- Phase 4: 1.75 hours (Speaker Dialog) +- Phase 5: 1.75 hours (Episode Integration) +- Phase 6: 0.5 hours (Final Actions) + +**The podcast page now provides an intuitive, efficient workflow that completely eliminates the original UX confusion!** 🚀 + +## PHASE 7: Polish & Final Testing [Not Started ⏳] + +Add final polish, optimize performance, and conduct comprehensive testing. + +### UI/UX polish [Not Started ⏳] + +- Improve visual styling and spacing throughout Templates tab +- Add loading states for API operations and better user feedback +- Enhance error messaging to be more helpful and user-friendly +- Ensure consistent styling between main area and sidebar + +**Time Estimate**: 45 minutes +**Dependencies**: Phase 6 completed +**Testing**: UI feels polished and provides good user feedback + +### Performance optimization [Not Started ⏳] + +- Optimize data loading patterns with efficient API calls +- Minimize unnecessary re-renders when dialogs open/close +- Test performance with realistic numbers of profiles +- Ensure smooth user experience even with many profiles + +**Time Estimate**: 30 minutes +**Dependencies**: UI polish completed +**Testing**: Performance testing with large datasets + +### Comprehensive end-to-end testing [Not Started ⏳] + +- Test all workflows: create speaker → create episode, edit workflows, delete workflows +- Test edge cases: no profiles, many profiles, invalid references, API errors +- Verify Episodes tab remained completely unchanged +- Test dialog interactions and session state management +- Validate all existing functionality still works + +**Time Estimate**: 45 minutes +**Dependencies**: Performance optimization completed +**Testing**: Complete validation of all functionality and edge cases + +### Comments: +- This phase ensures production-ready quality +- Focus on edge cases and error scenarios +- Comprehensive testing prevents regressions + +--- + +## Implementation Notes + +### Sequential Dependencies +- Phases 1-3 must be completed in order (foundation → sidebar → main area) +- Phases 4-5 must be completed in order (dialog → integration) +- Phases 6-7 can begin after Phase 5 is complete + +### Parallel Work Opportunities +- Phase 2 tasks (sidebar components) can be worked on in parallel +- Phase 6 tasks (edit/duplicate/delete) can be implemented in parallel +- Testing can happen in parallel with development within each phase + +### Key Differences from Original Plan +- **2 tabs instead of single page**: Episodes tab preserved unchanged +- **Templates tab combines**: Episode profiles + speaker profiles in single interface +- **Reduced scope**: Less complex than eliminating all tabs +- **Lower risk**: Episodes functionality completely preserved + +### Risk Mitigation +- Episodes tab remains completely unchanged (zero regression risk) +- Each phase maintains working functionality +- Rollback possible at any phase boundary +- Comprehensive testing prevents regressions + +### Total Estimated Time: 12 hours (7 phases × ~1.7 hours average) \ No newline at end of file diff --git a/.claude/sessions/podcast_page/requirements.txt b/.claude/sessions/podcast_page/requirements.txt new file mode 100644 index 0000000..87a6baf --- /dev/null +++ b/.claude/sessions/podcast_page/requirements.txt @@ -0,0 +1,56 @@ + + + + + + + +When you look at the Podcast page, you'll see we have a tab for managign speaker_profiles and another for managing episode_prfiles. + +The idea was to reuse speaker profiles for different episodes. But this ended up making the interface a bit complex and making our users confused. +People don't understand they should do speakers before episode profiles. + +So I am wondering if we can't keep this relationship between speaker profiles and episode profiles, but solve it in a single page. + +My initial though is to have the episode profiles and, when working on the episode profile, open the speaker config through a dialog using st.dialog. +If my profile is not there, I can ask to create one, which also happens inside the dialog. + +There will also be a list of speaker profiles in a different column in case I want to duplicate, delete or edit it. +Editing also happens on a st.dialog so we dont make the page too complex. + +This page should also have a header paragraph explaining how the whole thing works so people understand the relationship between episode profiles and speaker profiles. + + + +This is an example of a speaker profile: + + { + description: 'Single expert for educational content', + name: 'solo_expert', + speakers: [ + { + backstory: 'Distinguished professor and researcher. Has a gift for making complex topics accessible to broad audiences.', + name: 'Professor Sarah Kim', + personality: 'Patient teacher, uses analogies and examples, breaks down complex concepts step by step', + voice_id: 'nova' + } + ], + tts_model: 'tts-1', + tts_provider: 'openai', + } + +And this is an example for the episode profile + + { + default_briefing: 'Analyze the provided content from a business perspective. Discuss market implications, strategic insights, competitive advantages, and actionable business intelligence.', + description: 'Business-focused analysis and discussion', + name: 'business_analysis', + num_segments: 6, + outline_model: 'gpt-4o-mini', + outline_provider: 'openai', + speaker_config: 'business_panel', + transcript_model: 'gpt-4o-mini', + transcript_provider: 'openai', + } + + diff --git a/.dockerignore b/.dockerignore index 5623f9c..2d94a4e 100644 --- a/.dockerignore +++ b/.dockerignore @@ -2,8 +2,6 @@ notebooks/ data/ .uploads/ .venv/ -.mypy_cache/ -.ruff_cache/ .env sqlite-db/ temp/ @@ -16,8 +14,39 @@ surreal-data/ notebook_data/ temp/ *.env -.mypy_cache/ -.ruff_cache/ -.pytest_cache -.ruff_cache -notebooks/ + +# Cache directories (recursive patterns) +**/__pycache__/ +**/.mypy_cache/ +**/.ruff_cache/ +**/.pytest_cache/ +**/*.pyc +**/*.pyo +**/*.pyd +.coverage +.coverage.* +htmlcov/ +.tox/ +.nox/ +.cache/ +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ + +# IDE and editor files +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS files +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db diff --git a/.env.example b/.env.example index 2b397a9..4f805a7 100644 --- a/.env.example +++ b/.env.example @@ -1,4 +1,7 @@ +# SECURITY +# Set this to protect your Open Notebook instance with a password (for public hosting) +# OPEN_NOTEBOOK_PASSWORD= # OPENAI # OPENAI_API_KEY= @@ -55,14 +58,21 @@ # LANGCHAIN_PROJECT="Open Notebook" # CONNECTION DETAILS FOR YOUR SURREAL DB -# Use surrealdb if using docker-compose or add your server ip if using a different setup -SURREAL_ADDRESS="localhost" -SURREAL_PORT=8000 +# New format (preferred) - WebSocket URL +SURREAL_URL="ws://surrealdb/rpc:8000" SURREAL_USER="root" -SURREAL_PASS="root" +SURREAL_PASSWORD="root" SURREAL_NAMESPACE="open_notebook" SURREAL_DATABASE="staging" +# Old format (backward compatible) - will be converted automatically +# SURREAL_ADDRESS="localhost" +# SURREAL_PORT=8000 +# SURREAL_USER="root" +# SURREAL_PASS="root" +# SURREAL_NAMESPACE="open_notebook" +# SURREAL_DATABASE="staging" + # FIRECRAWL - Get a key at https://firecrawl.dev/ FIRECRAWL_API_KEY= diff --git a/.gitignore b/.gitignore index d70078e..7309133 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -*.env +.env prompts/patterns/user/ notebooks/ data/ @@ -6,6 +6,7 @@ data/ sqlite-db/ surreal-data/ docker.env +!setup_guide/docker.env notebook_data/ # Python-specific *.py[cod] @@ -119,4 +120,6 @@ desktop.ini *.db *.sqlite3 -.quarentena \ No newline at end of file +.quarentena + +.claude/logs \ No newline at end of file diff --git a/.streamlit/config.toml b/.streamlit/config.toml index 45dd123..63ad128 100644 --- a/.streamlit/config.toml +++ b/.streamlit/config.toml @@ -1,7 +1,7 @@ [server] port = 8502 maxMessageSize = 500 -fileWatcherType = "none" +# fileWatcherType = "none" [browser] serverPort = 8502 diff --git a/Dockerfile b/Dockerfile index 077036f..bbdd084 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,27 +1,66 @@ -# Use Python 3.11 slim image as base -FROM python:3.11-slim-bookworm +# Build stage +FROM python:3.12-slim-bookworm AS builder # Install uv using the official method COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ - # Install system dependencies required for building certain Python packages RUN apt-get update && apt-get upgrade -y && apt-get install -y \ gcc g++ git make \ libmagic-dev \ - ffmpeg \ && rm -rf /var/lib/apt/lists/* +# Set build optimization environment variables +ENV MAKEFLAGS="-j$(nproc)" +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 +ENV UV_COMPILE_BYTECODE=1 +ENV UV_LINK_MODE=copy + # Set the working directory in the container to /app WORKDIR /app +# Copy dependency files and minimal package structure first for better layer caching +COPY pyproject.toml uv.lock ./ +COPY open_notebook/__init__.py ./open_notebook/__init__.py + +# Install dependencies with optimizations (this layer will be cached unless dependencies change) +RUN uv sync --frozen --no-dev + +# Copy the rest of the application code COPY . /app -RUN uv sync +# Runtime stage +FROM python:3.12-slim-bookworm AS runtime +# Install only runtime system dependencies (no build tools) +RUN apt-get update && apt-get upgrade -y && apt-get install -y \ + libmagic1 \ + ffmpeg \ + supervisor \ + && rm -rf /var/lib/apt/lists/* -EXPOSE 8502 +# Install uv using the official method +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +# Set the working directory in the container to /app +WORKDIR /app + +# Copy the virtual environment from builder stage +COPY --from=builder /app/.venv /app/.venv + +# Copy the application code +COPY --from=builder /app /app + +# Expose ports for Streamlit and API +EXPOSE 8502 5055 RUN mkdir -p /app/data -CMD ["uv", "run", "streamlit", "run", "app_home.py"] +# Copy supervisord configuration +COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf + +# Create log directories +RUN mkdir -p /var/log/supervisor + +CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"] diff --git a/Dockerfile.single b/Dockerfile.single index 4c9af1f..3b4c652 100644 --- a/Dockerfile.single +++ b/Dockerfile.single @@ -1,34 +1,72 @@ -# Use Python 3.11 slim image as base -FROM python:3.11-slim-bookworm +# Build stage +FROM python:3.12-slim-bookworm AS builder # Install uv using the official method COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ - # Install system dependencies required for building certain Python packages RUN apt-get update && apt-get upgrade -y && apt-get install -y \ - gcc \ - curl wget libmagic-dev ffmpeg supervisor \ + gcc g++ git make \ + libmagic-dev \ + && rm -rf /var/lib/apt/lists/* + +# Set build optimization environment variables +ENV MAKEFLAGS="-j$(nproc)" +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 +ENV UV_COMPILE_BYTECODE=1 +ENV UV_LINK_MODE=copy + +# Set the working directory in the container to /app +WORKDIR /app + +# Copy dependency files and minimal package structure first for better layer caching +COPY pyproject.toml uv.lock ./ +COPY open_notebook/__init__.py ./open_notebook/__init__.py + +# Install dependencies with optimizations (this layer will be cached unless dependencies change) +RUN uv sync --frozen --no-dev + +# Copy the rest of the application code +COPY . /app + +# Runtime stage +FROM python:3.12-slim-bookworm AS runtime + +# Install runtime system dependencies including curl for SurrealDB installation +RUN apt-get update && apt-get upgrade -y && apt-get install -y \ + libmagic1 \ + ffmpeg \ + supervisor \ + curl \ && rm -rf /var/lib/apt/lists/* # Install SurrealDB RUN curl --proto '=https' --tlsv1.2 -sSf https://install.surrealdb.com | sh +# Install uv using the official method +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + # Set the working directory in the container to /app WORKDIR /app -COPY . /app -RUN uv sync +# Copy the virtual environment from builder stage +COPY --from=builder /app/.venv /app/.venv -# Create supervisor configuration directory -RUN mkdir -p /etc/supervisor/conf.d +# Copy the application code +COPY --from=builder /app /app -# Copy supervisor configuration file -COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf +# Create directories for data persistence +RUN mkdir -p /app/data /mydata -EXPOSE 8502 +# Expose ports for Streamlit and API +EXPOSE 8502 5055 -RUN mkdir -p /app/data +# Copy single-container supervisord configuration +COPY supervisord.single.conf /etc/supervisor/conf.d/supervisord.conf -# Use supervisor as the main process -CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"] +# Create log directories +RUN mkdir -p /var/log/supervisor + + +CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"] \ No newline at end of file diff --git a/Makefile b/Makefile index 703700c..2e72bc1 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: run check ruff database lint docker-build docker-push docker-buildx-prepare docker-release +.PHONY: run check ruff database lint docker-build docker-build-dev docker-build-multi-test docker-build-multi-load docker-push docker-buildx-prepare docker-release api start-all stop-all status clean-cache docker-build-dev-clean docker-build-single-dev docker-build-single-multi-test docker-build-single docker-build-single-latest docker-release-single docker-release-both docker-release-all-versions # Get version from pyproject.toml VERSION := $(shell grep -m1 version pyproject.toml | cut -d'"' -f2) @@ -7,9 +7,10 @@ IMAGE_NAME := lfnovo/open_notebook PLATFORMS=linux/amd64,linux/arm64 database: - docker compose --profile db_only up + docker compose up -d surrealdb run: + @echo "⚠️ Warning: Starting UI only. For full functionality, use 'make start-all'" uv run --env-file .env streamlit run app_home.py lint: @@ -20,9 +21,31 @@ ruff: # buildx config for multi-plataform docker-buildx-prepare: - docker buildx create --use --name multi-platform-builder || true + docker buildx create --use --name multi-platform-builder --driver docker-container || \ + docker buildx use multi-platform-builder -# multi-plataform build with buildx +# Single-platform build for development (much faster) +docker-build-dev: + docker build \ + -t $(IMAGE_NAME):$(VERSION)-dev \ + . + +# Multi-platform build test (builds both platforms, doesn't load or push) +docker-build-multi-test: docker-buildx-prepare + docker buildx build --pull \ + --platform $(PLATFORMS) \ + -t $(IMAGE_NAME):$(VERSION)-multi \ + . + +# Load current platform only from multi-platform build +docker-build-multi-load: docker-buildx-prepare + docker buildx build --pull \ + --platform linux/amd64 \ + -t $(IMAGE_NAME):$(VERSION)-multi \ + --load \ + . + +# multi-plataform build with buildx (pushes to registry) docker-build: docker-buildx-prepare docker buildx build --pull \ --platform $(PLATFORMS) \ @@ -58,4 +81,122 @@ dev: docker compose -f docker-compose.dev.yml up --build full: - docker compose -f docker-compose.full.yml up --build \ No newline at end of file + docker compose -f docker-compose.full.yml up --build + + +api: + uv run run_api.py + +# === Worker Management === +.PHONY: worker worker-start worker-stop worker-restart + +worker: worker-start + +worker-start: + @echo "Starting surreal-commands worker..." + uv run --env-file .env surreal-commands-worker --import-modules commands + +worker-stop: + @echo "Stopping surreal-commands worker..." + pkill -f "surreal-commands-worker" || true + +worker-restart: worker-stop + @sleep 2 + @$(MAKE) worker-start + +# === Service Management === +start-all: + @echo "🚀 Starting Open Notebook (Database + API + Worker + UI)..." + @echo "📊 Starting SurrealDB..." + @docker compose up -d surrealdb + @sleep 3 + @echo "🔧 Starting API backend..." + @uv run run_api.py & + @sleep 3 + @echo "⚙️ Starting background worker..." + @uv run --env-file .env surreal-commands-worker --import-modules commands & + @sleep 2 + @echo "🌐 Starting Streamlit UI..." + @echo "✅ All services started!" + @echo "📱 UI: http://localhost:8502" + @echo "🔗 API: http://localhost:5055" + @echo "📚 API Docs: http://localhost:5055/docs" + uv run --env-file .env streamlit run app_home.py + +stop-all: + @echo "🛑 Stopping all Open Notebook services..." + @pkill -f "streamlit run app_home.py" || true + @pkill -f "surreal-commands-worker" || true + @pkill -f "run_api.py" || true + @pkill -f "uvicorn api.main:app" || true + @docker compose down + @echo "✅ All services stopped!" + +status: + @echo "📊 Open Notebook Service Status:" + @echo "Database (SurrealDB):" + @docker compose ps surrealdb 2>/dev/null || echo " ❌ Not running" + @echo "API Backend:" + @pgrep -f "run_api.py\|uvicorn api.main:app" >/dev/null && echo " ✅ Running" || echo " ❌ Not running" + @echo "Background Worker:" + @pgrep -f "surreal-commands-worker" >/dev/null && echo " ✅ Running" || echo " ❌ Not running" + @echo "Streamlit UI:" + @pgrep -f "streamlit run app_home.py" >/dev/null && echo " ✅ Running" || echo " ❌ Not running" + +# Clean up cache directories to reduce build context size +clean-cache: + @echo "🧹 Cleaning cache directories..." + @find . -name "__pycache__" -type d -exec rm -rf {} + 2>/dev/null || true + @find . -name ".mypy_cache" -type d -exec rm -rf {} + 2>/dev/null || true + @find . -name ".ruff_cache" -type d -exec rm -rf {} + 2>/dev/null || true + @find . -name ".pytest_cache" -type d -exec rm -rf {} + 2>/dev/null || true + @find . -name "*.pyc" -type f -delete 2>/dev/null || true + @find . -name "*.pyo" -type f -delete 2>/dev/null || true + @find . -name "*.pyd" -type f -delete 2>/dev/null || true + @echo "✅ Cache directories cleaned!" + +# Fast development build with cache cleanup +docker-build-dev-clean: clean-cache docker-build-dev + +# === Single Container Builds === +# Single-container build for development (much faster) +docker-build-single-dev: + docker build \ + -f Dockerfile.single \ + -t $(IMAGE_NAME):$(VERSION)-single-dev \ + . + +# Single-container multi-platform build test +docker-build-single-multi-test: docker-buildx-prepare + docker buildx build --pull \ + --platform $(PLATFORMS) \ + -f Dockerfile.single \ + -t $(IMAGE_NAME):$(VERSION)-single-multi \ + . + +# Single-container multi-platform build with buildx (pushes to registry) +docker-build-single: docker-buildx-prepare + docker buildx build --pull \ + --platform $(PLATFORMS) \ + -f Dockerfile.single \ + -t $(IMAGE_NAME):$(VERSION)-single \ + --push \ + . + +# Single-container build and push with latest tag +docker-build-single-latest: docker-buildx-prepare + docker buildx build --pull \ + --platform $(PLATFORMS) \ + -f Dockerfile.single \ + -t $(IMAGE_NAME):latest-single \ + --push \ + . + +# Single-container release (both versioned and latest) +docker-release-single: docker-build-single docker-build-single-latest + +# Release both multi-container and single-container versions +docker-release-both: docker-release docker-release-single + +# Release all versions (both multi and single with latest tags) +docker-release-all-versions: docker-release-all docker-release-single \ No newline at end of file diff --git a/README.md b/README.md index b70a8d7..5ed7515 100644 --- a/README.md +++ b/README.md @@ -34,16 +34,12 @@ ## 📢 Open Notebook is under very active development > Open Notebook is under active development! We're moving fast and making improvements every week. Your feedback is incredibly valuable to me during this exciting phase and it gives me motivation to keep improving and building this amazing tool. Please feel free to star the project if you find it useful, and don't hesitate to reach out with any questions or suggestions. I'm excited to see how you'll use it and what ideas you'll bring to the project! Let's build something amazing together! 🚀 -> -> ⚠️ **API Changes**: As we optimize and enhance the project, some APIs and interfaces might change. We'll do our best to document these changes and minimize disruption. -> -> 🙏 **We Need Your Feedback**: Please try out Open Notebook and let us know what you think! Submit issues, feature requests, or just share your experience through: -> - GitHub Issues -> - Discussions -> - Pull Requests -> -> Together, we can make it even better! +## Installation Issues? + +> We have a CustomGPT built to help you install Open Notebook. [Check it out here](https://chatgpt.com/g/g-68776e2765b48191bd1bae3f30212631-open-notebook-installation-assistant). It will help you through each step of the process. + +> There are also some [basic docker/openai installation guide](setup_guide/README.md) available if you prefer to install it manually.
@@ -60,6 +56,7 @@
  • Usage
    • @@ -129,6 +126,40 @@ cp .env.example docker.env Edit .env for your API keys. +### 🔐 Password Protection (Optional) + +For users hosting Open Notebook publicly (e.g., on PikaPods, cloud services), you can protect your instance with a password: + +```bash +# Add this to your .env file +OPEN_NOTEBOOK_PASSWORD=your_secure_password_here +``` + +When this environment variable is set: +- **Streamlit UI**: Users must enter the password on first access +- **REST API**: All API calls require the password in the Authorization header (`Authorization: Bearer your_password`) +- **Local Usage**: If not set, no authentication is required (default behavior) + +**API Usage with Password:** +```bash +# Example API call with password +curl -H "Authorization: Bearer your_password" http://localhost:5055/api/notebooks +``` + +This provides basic protection for public deployments while keeping local usage simple and password-free. + +📚 **For detailed security information, see the [Security Guide](docs/security.md)**. + +### 🚀 Quick Start + +After setting up your environment, simply run: + +```bash +make start-all +``` + +This single command will start all required services (database, API, worker, and UI) for you! + ### System Dependencies This project requires some system dependencies: @@ -155,19 +186,67 @@ uv pip install python-magic ### Running the Application -Start the SurrealDB database first: +Open Notebook now requires **four services** to run: the database, API backend, worker, and Streamlit interface. + +#### ✨ Easiest Way: Use `make start-all` + +After completing the setup above, the recommended way to run Open Notebook is: ```bash -docker compose --profile db_only up -d +make start-all ``` -Then run the Streamlit application: +This single command will: +- Start **SurrealDB** database on port 8000 +- Start **FastAPI** backend on port 5055 +- Start **Background Worker** for podcast generation and transformations +- Start **Streamlit UI** on port 8502 + +Once running, access Open Notebook at `http://localhost:8502` 🎉 + +#### Manual Setup (Development) + +If you prefer to start services individually: ```bash -# Load environment variables from .env file and run the app -uv run --env-file .env streamlit run app_home.py +# 1. Start SurrealDB database +make database +# or: docker compose up -d surrealdb + +# 2. Start the FastAPI backend (in terminal 1) +make api +# or: uv run --env-file .env uvicorn api.main:app --host 0.0.0.0 --port 5055 + +# 3. Start the background worker (in terminal 2) +make worker +# or: uv run --env-file .env surreal-commands-worker --import-modules commands + +# 4. Start Streamlit UI (in terminal 3) +make run +# or: uv run --env-file .env streamlit run app_home.py ``` +#### Service Endpoints +- **Streamlit UI**: `http://localhost:8502` +- **REST API**: `http://localhost:5055` +- **API Documentation**: `http://localhost:5055/docs` (Interactive Swagger UI) +- **SurrealDB**: `http://localhost:8000` + +#### Service Management + +```bash +# Check if all services are running +make status + +# Stop all services +make stop-all + +# Restart worker only +make worker-restart +``` + +**Note**: The worker is required for podcast generation and content transformations. Without it, these features will queue jobs but not process them. + ## Provider Support Matrix Thanks to the [Esperanto](https://github.com/lfnovo/esperanto) library, we support this providers out of the box! @@ -212,12 +291,62 @@ uv run --env-file .env streamlit run app_home.py --server.port=8503 ### Running with Docker -If you don't want to mess around with the code and just want to run it as a docker image: +Open Notebook offers two Docker deployment options: + +#### Option 1: Multi-Container (Default) +If you prefer separate containers for each service: ```bash +# Run the full stack (SurrealDB + Streamlit + API) docker compose --profile multi up ``` +#### Option 2: Single-Container (Recommended for Simple Deployments) +For platforms like PikaPods or if you prefer an all-in-one solution: + +```bash +# Run everything in a single container +docker compose -f docker-compose.single.yml up -d +``` + +Or directly: + +```bash +docker run -d \ + --name open-notebook \ + -p 8502:8502 -p 5055:5055 \ + -v ./notebook_data:/app/data \ + -v ./surreal_single_data:/mydata \ + -e OPENAI_API_KEY=your_key \ + lfnovo/open_notebook:latest-single +``` + +Both setups provide: +- **Streamlit UI**: `http://localhost:8502` +- **REST API**: `http://localhost:5055` +- **API Documentation**: `http://localhost:5055/docs` (Interactive Swagger UI) + +**📚 For detailed single-container deployment instructions, see the [Single-Container Deployment Guide](docs/single-container-deployment.md)**. + +**Docker with Password Protection:** +To enable password protection in Docker, add `OPEN_NOTEBOOK_PASSWORD=your_password` to your environment variables. + +### API Documentation + +Open Notebook now includes a comprehensive REST API that provides programmatic access to all functionality. The API includes endpoints for: + +- **Notebooks**: Create, read, update, delete notebooks +- **Sources**: Manage research sources (links, files, text) +- **Notes**: Create and manage notes +- **Search**: Full-text and vector search capabilities +- **Models**: Manage AI models and providers +- **Transformations**: Execute content transformations +- **Settings**: Application configuration +- **Context**: Generate context for AI interactions +- **Embedding**: Vectorize content for search + +Visit `http://localhost:5055/docs` when the API is running to explore the interactive API documentation. +

    (back to top)

    ## Usage @@ -231,7 +360,9 @@ Go to the [Usage](docs/USAGE.md) page to learn how to use all features. - **Multi-Notebook Support**: Organize your research across multiple notebooks effortlessly. - **Multi-model support**: Open AI, Anthropic, Gemini, Vertex AI, Open Router, X.AI, Groq, Ollama. ([Model Selection Guide](https://github.com/lfnovo/open-notebook/blob/main/docs/models.md)) - **Reasoning Model Support**: Full support for thinking models like DeepSeek-R1, Qwen3, and Magistral with collapsible reasoning sections. -- **Podcast Generator**: Automatically convert your notes into a podcast format. +- **Comprehensive REST API**: Full programmatic access to all functionality for building custom integrations. +- **Optional Password Protection**: Secure your public deployments with simple password authentication for both UI and API. +- **Advanced Podcast Generator**: Create professional podcasts with 1-4 speakers using Episode Profiles. Superior flexibility compared to Google Notebook LM's 2-speaker limitation. - **Broad Content Integration**: Works with links, PDFs, EPUB, Office, TXT, Markdown files, YouTube videos, Audio files, Video files and pasted text. - **Content Transformation**: Powerful customizable actions to summarize, extract insights, and more. - **AI-Powered Notes**: Write notes yourself or let the AI assist you in generating insights. @@ -275,13 +406,15 @@ Jinja based prompts that are easy to customize to your own preferences. ## Roadmap +- [ ] **React Frontend**: Modern React-based frontend to replace Streamlit. - [ ] **Live Front-End Updates**: Real-time UI updates for a smoother experience. - [ ] **Async Processing**: Faster UI through asynchronous content processing. - [ ] **Cross-Notebook Sources and Notes**: Reuse research notes across projects. - [ ] **Bookmark Integration**: Integrate with your favorite bookmarking app. +- ✅ **Comprehensive REST API**: Full API coverage for all functionality. - ✅ **Multi-model support**: Open AI, Anthropic, Vertex AI, Open Router, Ollama, etc. - ✅ **Insight Generation**: New tools for creating insights - [transformations](docs/TRANSFORMATIONS.md) -- ✅ **Podcast Generator**: Automatically convert your notes into a podcast format. +- ✅ **Advanced Podcast Generator**: Professional multi-speaker podcasts with Episode Profiles and background processing. - ✅ **Multiple Chat Sessions**: Juggle different discussions within the same notebook. - ✅ **Enhanced Citations**: Improved layout and finer control for citations. - ✅ **Better Embeddings & Summarization**: Smarter ways to distill information. @@ -328,7 +461,8 @@ Join our [Discord server](https://discord.gg/37XJPXfz2w) for help, share workflo This project uses some amazing third-party libraries -* [Podcastfy](https://github.com/souzatharsis/podcastfy) - Licensed under the Apache License 2.0 +* [Podcast Creator](https://github.com/lfnovo/podcast-creator) - Licensed under the MIT License +* [Surreal Commands](https://github.com/lfnovo/surreal-commands) - Licensed under the MIT License * [Content Core](https://github.com/lfnovo/content-core) - Licensed under the MIT License * [Docling](https://github.com/docling-project/docling) - Licensed under the MIT License * [Esperanto](https://github.com/lfnovo/esperanto) - Licensed under the MIT License diff --git a/api/__init__.py b/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/api/auth.py b/api/auth.py new file mode 100644 index 0000000..a9d51aa --- /dev/null +++ b/api/auth.py @@ -0,0 +1,96 @@ +import os +from typing import Optional + +from fastapi import HTTPException, Request +from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials +from starlette.middleware.base import BaseHTTPMiddleware +from starlette.responses import JSONResponse + + +class PasswordAuthMiddleware(BaseHTTPMiddleware): + """ + Middleware to check password authentication for all API requests. + Only active when OPEN_NOTEBOOK_PASSWORD environment variable is set. + """ + + def __init__(self, app, excluded_paths: Optional[list] = None): + super().__init__(app) + self.password = os.environ.get("OPEN_NOTEBOOK_PASSWORD") + self.excluded_paths = excluded_paths or ["/", "/health", "/docs", "/openapi.json", "/redoc"] + + async def dispatch(self, request: Request, call_next): + # Skip authentication if no password is set + if not self.password: + return await call_next(request) + + # Skip authentication for excluded paths + if request.url.path in self.excluded_paths: + return await call_next(request) + + # Check authorization header + auth_header = request.headers.get("Authorization") + + if not auth_header: + return JSONResponse( + status_code=401, + content={"detail": "Missing authorization header"}, + headers={"WWW-Authenticate": "Bearer"} + ) + + # Expected format: "Bearer {password}" + try: + scheme, credentials = auth_header.split(" ", 1) + if scheme.lower() != "bearer": + raise ValueError("Invalid authentication scheme") + except ValueError: + return JSONResponse( + status_code=401, + content={"detail": "Invalid authorization header format"}, + headers={"WWW-Authenticate": "Bearer"} + ) + + # Check password + if credentials != self.password: + return JSONResponse( + status_code=401, + content={"detail": "Invalid password"}, + headers={"WWW-Authenticate": "Bearer"} + ) + + # Password is correct, proceed with the request + response = await call_next(request) + return response + + +# Optional: HTTPBearer security scheme for OpenAPI documentation +security = HTTPBearer(auto_error=False) + + +def check_api_password(credentials: HTTPAuthorizationCredentials = None) -> bool: + """ + Utility function to check API password. + Can be used as a dependency in individual routes if needed. + """ + password = os.environ.get("OPEN_NOTEBOOK_PASSWORD") + + # No password set, allow access + if not password: + return True + + # No credentials provided + if not credentials: + raise HTTPException( + status_code=401, + detail="Missing authorization", + headers={"WWW-Authenticate": "Bearer"}, + ) + + # Check password + if credentials.credentials != password: + raise HTTPException( + status_code=401, + detail="Invalid password", + headers={"WWW-Authenticate": "Bearer"}, + ) + + return True \ No newline at end of file diff --git a/api/client.py b/api/client.py new file mode 100644 index 0000000..20d0fdd --- /dev/null +++ b/api/client.py @@ -0,0 +1,405 @@ +""" +API client for Open Notebook API. +This module provides a client interface to interact with the Open Notebook API. +""" + +import os +from typing import Dict, List, Optional + +import httpx +from loguru import logger + + +class APIClient: + """Client for Open Notebook API.""" + + def __init__(self, base_url: Optional[str] = None): + self.base_url = base_url or os.getenv("API_BASE_URL", "http://127.0.0.1:5055") + self.timeout = 30.0 + # Add authentication header if password is set + self.headers = {} + password = os.getenv("OPEN_NOTEBOOK_PASSWORD") + if password: + self.headers["Authorization"] = f"Bearer {password}" + + def _make_request( + self, method: str, endpoint: str, timeout: Optional[float] = None, **kwargs + ) -> Dict: + """Make HTTP request to the API.""" + url = f"{self.base_url}{endpoint}" + request_timeout = timeout if timeout is not None else self.timeout + + # Merge headers + headers = kwargs.get("headers", {}) + headers.update(self.headers) + kwargs["headers"] = headers + + try: + with httpx.Client(timeout=request_timeout) as client: + response = client.request(method, url, **kwargs) + response.raise_for_status() + return response.json() + except httpx.RequestError as e: + logger.error(f"Request error for {method} {url}: {str(e)}") + raise ConnectionError(f"Failed to connect to API: {str(e)}") + except httpx.HTTPStatusError as e: + logger.error( + f"HTTP error {e.response.status_code} for {method} {url}: {e.response.text}" + ) + raise RuntimeError( + f"API request failed: {e.response.status_code} - {e.response.text}" + ) + except Exception as e: + logger.error(f"Unexpected error for {method} {url}: {str(e)}") + raise + + # Notebooks API methods + def get_notebooks( + self, archived: Optional[bool] = None, order_by: str = "updated desc" + ) -> List[Dict]: + """Get all notebooks.""" + params = {"order_by": order_by} + if archived is not None: + params["archived"] = archived + + return self._make_request("GET", "/api/notebooks", params=params) + + def create_notebook(self, name: str, description: str = "") -> Dict: + """Create a new notebook.""" + data = {"name": name, "description": description} + return self._make_request("POST", "/api/notebooks", json=data) + + def get_notebook(self, notebook_id: str) -> Dict: + """Get a specific notebook.""" + return self._make_request("GET", f"/api/notebooks/{notebook_id}") + + def update_notebook(self, notebook_id: str, **updates) -> Dict: + """Update a notebook.""" + return self._make_request("PUT", f"/api/notebooks/{notebook_id}", json=updates) + + def delete_notebook(self, notebook_id: str) -> Dict: + """Delete a notebook.""" + return self._make_request("DELETE", f"/api/notebooks/{notebook_id}") + + # Search API methods + def search( + self, + query: str, + search_type: str = "text", + limit: int = 100, + search_sources: bool = True, + search_notes: bool = True, + minimum_score: float = 0.2, + ) -> Dict: + """Search the knowledge base.""" + data = { + "query": query, + "type": search_type, + "limit": limit, + "search_sources": search_sources, + "search_notes": search_notes, + "minimum_score": minimum_score, + } + return self._make_request("POST", "/api/search", json=data) + + def ask_simple( + self, + question: str, + strategy_model: str, + answer_model: str, + final_answer_model: str, + ) -> Dict: + """Ask the knowledge base a question (simple, non-streaming).""" + data = { + "question": question, + "strategy_model": strategy_model, + "answer_model": answer_model, + "final_answer_model": final_answer_model, + } + # Use 5 minute timeout for long-running ask operations + return self._make_request( + "POST", "/api/search/ask/simple", json=data, timeout=300.0 + ) + + # Models API methods + def get_models(self, model_type: Optional[str] = None) -> List[Dict]: + """Get all models with optional type filtering.""" + params = {} + if model_type: + params["type"] = model_type + return self._make_request("GET", "/api/models", params=params) + + def create_model(self, name: str, provider: str, model_type: str) -> Dict: + """Create a new model.""" + data = { + "name": name, + "provider": provider, + "type": model_type, + } + return self._make_request("POST", "/api/models", json=data) + + def delete_model(self, model_id: str) -> Dict: + """Delete a model.""" + return self._make_request("DELETE", f"/api/models/{model_id}") + + def get_default_models(self) -> Dict: + """Get default model assignments.""" + return self._make_request("GET", "/api/models/defaults") + + def update_default_models(self, **defaults) -> Dict: + """Update default model assignments.""" + return self._make_request("PUT", "/api/models/defaults", json=defaults) + + # Transformations API methods + def get_transformations(self) -> List[Dict]: + """Get all transformations.""" + return self._make_request("GET", "/api/transformations") + + def create_transformation( + self, + name: str, + title: str, + description: str, + prompt: str, + apply_default: bool = False, + ) -> Dict: + """Create a new transformation.""" + data = { + "name": name, + "title": title, + "description": description, + "prompt": prompt, + "apply_default": apply_default, + } + return self._make_request("POST", "/api/transformations", json=data) + + def get_transformation(self, transformation_id: str) -> Dict: + """Get a specific transformation.""" + return self._make_request("GET", f"/api/transformations/{transformation_id}") + + def update_transformation(self, transformation_id: str, **updates) -> Dict: + """Update a transformation.""" + return self._make_request( + "PUT", f"/api/transformations/{transformation_id}", json=updates + ) + + def delete_transformation(self, transformation_id: str) -> Dict: + """Delete a transformation.""" + return self._make_request("DELETE", f"/api/transformations/{transformation_id}") + + def execute_transformation( + self, transformation_id: str, input_text: str, model_id: str + ) -> Dict: + """Execute a transformation on input text.""" + data = { + "transformation_id": transformation_id, + "input_text": input_text, + "model_id": model_id, + } + # Use extended timeout for transformation operations + return self._make_request( + "POST", "/api/transformations/execute", json=data, timeout=120.0 + ) + + # Notes API methods + def get_notes(self, notebook_id: Optional[str] = None) -> List[Dict]: + """Get all notes with optional notebook filtering.""" + params = {} + if notebook_id: + params["notebook_id"] = notebook_id + return self._make_request("GET", "/api/notes", params=params) + + def create_note( + self, + content: str, + title: Optional[str] = None, + note_type: str = "human", + notebook_id: Optional[str] = None, + ) -> Dict: + """Create a new note.""" + data = { + "content": content, + "note_type": note_type, + } + if title: + data["title"] = title + if notebook_id: + data["notebook_id"] = notebook_id + return self._make_request("POST", "/api/notes", json=data) + + def get_note(self, note_id: str) -> Dict: + """Get a specific note.""" + return self._make_request("GET", f"/api/notes/{note_id}") + + def update_note(self, note_id: str, **updates) -> Dict: + """Update a note.""" + return self._make_request("PUT", f"/api/notes/{note_id}", json=updates) + + def delete_note(self, note_id: str) -> Dict: + """Delete a note.""" + return self._make_request("DELETE", f"/api/notes/{note_id}") + + # Embedding API methods + def embed_content(self, item_id: str, item_type: str) -> Dict: + """Embed content for vector search.""" + data = { + "item_id": item_id, + "item_type": item_type, + } + # Use extended timeout for embedding operations + return self._make_request("POST", "/api/embed", json=data, timeout=120.0) + + # Settings API methods + def get_settings(self) -> Dict: + """Get all application settings.""" + return self._make_request("GET", "/api/settings") + + def update_settings(self, **settings) -> Dict: + """Update application settings.""" + return self._make_request("PUT", "/api/settings", json=settings) + + # Context API methods + def get_notebook_context( + self, notebook_id: str, context_config: Optional[Dict] = None + ) -> Dict: + """Get context for a notebook.""" + data = {"notebook_id": notebook_id} + if context_config: + data["context_config"] = context_config + return self._make_request( + "POST", f"/api/notebooks/{notebook_id}/context", json=data + ) + + # Sources API methods + def get_sources(self, notebook_id: Optional[str] = None) -> List[Dict]: + """Get all sources with optional notebook filtering.""" + params = {} + if notebook_id: + params["notebook_id"] = notebook_id + return self._make_request("GET", "/api/sources", params=params) + + def create_source( + self, + notebook_id: str, + source_type: str, + url: Optional[str] = None, + file_path: Optional[str] = None, + content: Optional[str] = None, + title: Optional[str] = None, + transformations: Optional[List[str]] = None, + embed: bool = False, + delete_source: bool = False, + ) -> Dict: + """Create a new source.""" + data = { + "notebook_id": notebook_id, + "type": source_type, + "embed": embed, + "delete_source": delete_source, + } + if url: + data["url"] = url + if file_path: + data["file_path"] = file_path + if content: + data["content"] = content + if title: + data["title"] = title + if transformations: + data["transformations"] = transformations + + return self._make_request("POST", "/api/sources", json=data) + + def get_source(self, source_id: str) -> Dict: + """Get a specific source.""" + return self._make_request("GET", f"/api/sources/{source_id}") + + def update_source(self, source_id: str, **updates) -> Dict: + """Update a source.""" + return self._make_request("PUT", f"/api/sources/{source_id}", json=updates) + + def delete_source(self, source_id: str) -> Dict: + """Delete a source.""" + return self._make_request("DELETE", f"/api/sources/{source_id}") + + # Insights API methods + def get_source_insights(self, source_id: str) -> List[Dict]: + """Get all insights for a specific source.""" + return self._make_request("GET", f"/api/sources/{source_id}/insights") + + def get_insight(self, insight_id: str) -> Dict: + """Get a specific insight.""" + return self._make_request("GET", f"/api/insights/{insight_id}") + + def delete_insight(self, insight_id: str) -> Dict: + """Delete a specific insight.""" + return self._make_request("DELETE", f"/api/insights/{insight_id}") + + def save_insight_as_note( + self, insight_id: str, notebook_id: Optional[str] = None + ) -> Dict: + """Convert an insight to a note.""" + data = {} + if notebook_id: + data["notebook_id"] = notebook_id + return self._make_request( + "POST", f"/api/insights/{insight_id}/save-as-note", json=data + ) + + def create_source_insight( + self, source_id: str, transformation_id: str, model_id: Optional[str] = None + ) -> Dict: + """Create a new insight for a source by running a transformation.""" + data = {"transformation_id": transformation_id} + if model_id: + data["model_id"] = model_id + return self._make_request( + "POST", f"/api/sources/{source_id}/insights", json=data + ) + + # Episode Profiles API methods + def get_episode_profiles(self) -> List[Dict]: + """Get all episode profiles.""" + return self._make_request("GET", "/api/episode-profiles") + + def get_episode_profile(self, profile_name: str) -> Dict: + """Get a specific episode profile by name.""" + return self._make_request("GET", f"/api/episode-profiles/{profile_name}") + + def create_episode_profile( + self, + name: str, + description: str = "", + speaker_config: str = "", + outline_provider: str = "", + outline_model: str = "", + transcript_provider: str = "", + transcript_model: str = "", + default_briefing: str = "", + num_segments: int = 5, + ) -> Dict: + """Create a new episode profile.""" + data = { + "name": name, + "description": description, + "speaker_config": speaker_config, + "outline_provider": outline_provider, + "outline_model": outline_model, + "transcript_provider": transcript_provider, + "transcript_model": transcript_model, + "default_briefing": default_briefing, + "num_segments": num_segments, + } + return self._make_request("POST", "/api/episode-profiles", json=data) + + def update_episode_profile(self, profile_id: str, **updates) -> Dict: + """Update an episode profile.""" + return self._make_request("PUT", f"/api/episode-profiles/{profile_id}", json=updates) + + def delete_episode_profile(self, profile_id: str) -> Dict: + """Delete an episode profile.""" + return self._make_request("DELETE", f"/api/episode-profiles/{profile_id}") + + +# Global client instance +api_client = APIClient() diff --git a/api/command_service.py b/api/command_service.py new file mode 100644 index 0000000..3b7f64d --- /dev/null +++ b/api/command_service.py @@ -0,0 +1,92 @@ +from typing import Any, Dict, List, Optional + +from loguru import logger +from surreal_commands import get_command_status, submit_command + +from api.models import ErrorResponse + + +class CommandService: + """Generic service layer for command operations""" + + @staticmethod + async def submit_command_job( + module_name: str, # Actually app_name for surreal-commands + command_name: str, + command_args: Dict[str, Any], + context: Optional[Dict[str, Any]] = None, + ) -> str: + """Submit a generic command job for background processing""" + try: + # Ensure command modules are imported before submitting + # This is needed because submit_command validates against local registry + try: + import commands.podcast_commands # noqa: F401 + except ImportError as import_err: + logger.error(f"Failed to import command modules: {import_err}") + raise ValueError("Command modules not available") + + # surreal-commands expects: submit_command(app_name, command_name, args) + cmd_id = submit_command( + module_name, # This is actually the app name (e.g., "open_notebook") + command_name, # Command name (e.g., "process_text") + command_args, # Input data + ) + # Convert RecordID to string if needed + cmd_id_str = str(cmd_id) if cmd_id else None + logger.info( + f"Submitted command job: {cmd_id_str} for {module_name}.{command_name}" + ) + return cmd_id_str + + except Exception as e: + logger.error(f"Failed to submit command job: {e}") + raise + + @staticmethod + async def get_command_status(job_id: str) -> Dict[str, Any]: + """Get status of any command job""" + try: + status = await get_command_status(job_id) + return { + "job_id": job_id, + "status": status.status if status else "unknown", + "result": status.result if status else None, + "error_message": getattr(status, "error_message", None) + if status + else None, + "created": str(status.created) + if status and hasattr(status, "created") and status.created + else None, + "updated": str(status.updated) + if status and hasattr(status, "updated") and status.updated + else None, + "progress": getattr(status, "progress", None) if status else None, + } + except Exception as e: + logger.error(f"Failed to get command status: {e}") + raise + + @staticmethod + async def list_command_jobs( + module_filter: Optional[str] = None, + command_filter: Optional[str] = None, + status_filter: Optional[str] = None, + limit: int = 50, + ) -> List[Dict[str, Any]]: + """List command jobs with optional filtering""" + # This will be implemented with proper SurrealDB queries + # For now, return empty list as this is foundation phase + return [] + + @staticmethod + async def cancel_command_job(job_id: str) -> bool: + """Cancel a running command job""" + try: + # Implementation depends on surreal-commands cancellation support + # For now, just log the attempt + logger.info(f"Attempting to cancel job: {job_id}") + return True + except Exception as e: + logger.error(f"Failed to cancel command job: {e}") + raise diff --git a/api/context_service.py b/api/context_service.py new file mode 100644 index 0000000..6142177 --- /dev/null +++ b/api/context_service.py @@ -0,0 +1,32 @@ +""" +Context service layer using API. +""" + +from typing import Dict, Optional + +from loguru import logger + +from api.client import api_client + + +class ContextService: + """Service layer for context operations using API.""" + + def __init__(self): + logger.info("Using API for context operations") + + def get_notebook_context( + self, + notebook_id: str, + context_config: Optional[Dict] = None + ) -> Dict: + """Get context for a notebook.""" + result = api_client.get_notebook_context( + notebook_id=notebook_id, + context_config=context_config + ) + return result + + +# Global service instance +context_service = ContextService() \ No newline at end of file diff --git a/api/embedding_service.py b/api/embedding_service.py new file mode 100644 index 0000000..9a394f6 --- /dev/null +++ b/api/embedding_service.py @@ -0,0 +1,25 @@ +""" +Embedding service layer using API. +""" + +from typing import Dict + +from loguru import logger + +from api.client import api_client + + +class EmbeddingService: + """Service layer for embedding operations using API.""" + + def __init__(self): + logger.info("Using API for embedding operations") + + def embed_content(self, item_id: str, item_type: str) -> Dict[str, str]: + """Embed content for vector search.""" + result = api_client.embed_content(item_id=item_id, item_type=item_type) + return result + + +# Global service instance +embedding_service = EmbeddingService() \ No newline at end of file diff --git a/api/episode_profiles_service.py b/api/episode_profiles_service.py new file mode 100644 index 0000000..196141d --- /dev/null +++ b/api/episode_profiles_service.py @@ -0,0 +1,102 @@ +""" +Episode profiles service layer using API. +""" + +from typing import List + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.podcast import EpisodeProfile + + +class EpisodeProfilesService: + """Service layer for episode profiles operations using API.""" + + def __init__(self): + logger.info("Using API for episode profiles operations") + + def get_all_episode_profiles(self) -> List[EpisodeProfile]: + """Get all episode profiles.""" + profiles_data = api_client.get_episode_profiles() + # Convert API response to EpisodeProfile objects + profiles = [] + for profile_data in profiles_data: + profile = EpisodeProfile( + name=profile_data["name"], + description=profile_data.get("description", ""), + speaker_config=profile_data["speaker_config"], + outline_provider=profile_data["outline_provider"], + outline_model=profile_data["outline_model"], + transcript_provider=profile_data["transcript_provider"], + transcript_model=profile_data["transcript_model"], + default_briefing=profile_data["default_briefing"], + num_segments=profile_data["num_segments"] + ) + profile.id = profile_data["id"] + profiles.append(profile) + return profiles + + def get_episode_profile(self, profile_name: str) -> EpisodeProfile: + """Get a specific episode profile by name.""" + profile_data = api_client.get_episode_profile(profile_name) + profile = EpisodeProfile( + name=profile_data["name"], + description=profile_data.get("description", ""), + speaker_config=profile_data["speaker_config"], + outline_provider=profile_data["outline_provider"], + outline_model=profile_data["outline_model"], + transcript_provider=profile_data["transcript_provider"], + transcript_model=profile_data["transcript_model"], + default_briefing=profile_data["default_briefing"], + num_segments=profile_data["num_segments"] + ) + profile.id = profile_data["id"] + return profile + + def create_episode_profile( + self, + name: str, + description: str = "", + speaker_config: str = "", + outline_provider: str = "", + outline_model: str = "", + transcript_provider: str = "", + transcript_model: str = "", + default_briefing: str = "", + num_segments: int = 5, + ) -> EpisodeProfile: + """Create a new episode profile.""" + profile_data = api_client.create_episode_profile( + name=name, + description=description, + speaker_config=speaker_config, + outline_provider=outline_provider, + outline_model=outline_model, + transcript_provider=transcript_provider, + transcript_model=transcript_model, + default_briefing=default_briefing, + num_segments=num_segments, + ) + profile = EpisodeProfile( + name=profile_data["name"], + description=profile_data.get("description", ""), + speaker_config=profile_data["speaker_config"], + outline_provider=profile_data["outline_provider"], + outline_model=profile_data["outline_model"], + transcript_provider=profile_data["transcript_provider"], + transcript_model=profile_data["transcript_model"], + default_briefing=profile_data["default_briefing"], + num_segments=profile_data["num_segments"] + ) + profile.id = profile_data["id"] + return profile + + def delete_episode_profile(self, profile_id: str) -> bool: + """Delete an episode profile.""" + api_client.delete_episode_profile(profile_id) + return True + + +# Global service instance +episode_profiles_service = EpisodeProfilesService() \ No newline at end of file diff --git a/api/insights_service.py b/api/insights_service.py new file mode 100644 index 0000000..78c9d7e --- /dev/null +++ b/api/insights_service.py @@ -0,0 +1,82 @@ +""" +Insights service layer using API. +""" + +from typing import List, Optional + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.notebook import Note, SourceInsight + + +class InsightsService: + """Service layer for insights operations using API.""" + + def __init__(self): + logger.info("Using API for insights operations") + + def get_source_insights(self, source_id: str) -> List[SourceInsight]: + """Get all insights for a specific source.""" + insights_data = api_client.get_source_insights(source_id) + # Convert API response to SourceInsight objects + insights = [] + for insight_data in insights_data: + insight = SourceInsight( + insight_type=insight_data["insight_type"], + content=insight_data["content"], + ) + insight.id = insight_data["id"] + insight.created = insight_data["created"] + insight.updated = insight_data["updated"] + insights.append(insight) + return insights + + def get_insight(self, insight_id: str) -> SourceInsight: + """Get a specific insight.""" + insight_data = api_client.get_insight(insight_id) + insight = SourceInsight( + insight_type=insight_data["insight_type"], + content=insight_data["content"], + ) + insight.id = insight_data["id"] + insight.created = insight_data["created"] + insight.updated = insight_data["updated"] + # Store source_id as an attribute for easy access + insight._source_id = insight_data["source_id"] + return insight + + def delete_insight(self, insight_id: str) -> bool: + """Delete a specific insight.""" + api_client.delete_insight(insight_id) + return True + + def save_insight_as_note(self, insight_id: str, notebook_id: Optional[str] = None) -> Note: + """Convert an insight to a note.""" + note_data = api_client.save_insight_as_note(insight_id, notebook_id) + note = Note( + title=note_data["title"], + content=note_data["content"], + note_type=note_data["note_type"], + ) + note.id = note_data["id"] + note.created = note_data["created"] + note.updated = note_data["updated"] + return note + + def create_source_insight(self, source_id: str, transformation_id: str, model_id: Optional[str] = None) -> SourceInsight: + """Create a new insight for a source by running a transformation.""" + insight_data = api_client.create_source_insight(source_id, transformation_id, model_id) + insight = SourceInsight( + insight_type=insight_data["insight_type"], + content=insight_data["content"], + ) + insight.id = insight_data["id"] + insight.created = insight_data["created"] + insight.updated = insight_data["updated"] + insight._source_id = insight_data["source_id"] + return insight + + +# Global service instance +insights_service = InsightsService() \ No newline at end of file diff --git a/api/main.py b/api/main.py new file mode 100644 index 0000000..4db440a --- /dev/null +++ b/api/main.py @@ -0,0 +1,76 @@ +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware + +from api.auth import PasswordAuthMiddleware +from api.routers import commands as commands_router +from api.routers import ( + context, + embedding, + episode_profiles, + insights, + models, + notebooks, + notes, + podcasts, + search, + settings, + sources, + speaker_profiles, + transformations, +) + +# Import commands to register them in the API process +try: + from loguru import logger + + import commands.podcast_commands + + logger.info("Commands imported in API process") +except Exception as e: + from loguru import logger + + logger.error(f"Failed to import commands in API process: {e}") + +app = FastAPI( + title="Open Notebook API", + description="API for Open Notebook - Research Assistant", + version="0.2.2", +) + +# Add CORS middleware +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], # In production, replace with specific origins + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +# Add password authentication middleware +app.add_middleware(PasswordAuthMiddleware) + +# Include routers +app.include_router(notebooks.router, prefix="/api", tags=["notebooks"]) +app.include_router(search.router, prefix="/api", tags=["search"]) +app.include_router(models.router, prefix="/api", tags=["models"]) +app.include_router(transformations.router, prefix="/api", tags=["transformations"]) +app.include_router(notes.router, prefix="/api", tags=["notes"]) +app.include_router(embedding.router, prefix="/api", tags=["embedding"]) +app.include_router(settings.router, prefix="/api", tags=["settings"]) +app.include_router(context.router, prefix="/api", tags=["context"]) +app.include_router(sources.router, prefix="/api", tags=["sources"]) +app.include_router(insights.router, prefix="/api", tags=["insights"]) +app.include_router(commands_router.router, prefix="/api", tags=["commands"]) +app.include_router(podcasts.router, prefix="/api", tags=["podcasts"]) +app.include_router(episode_profiles.router, prefix="/api", tags=["episode-profiles"]) +app.include_router(speaker_profiles.router, prefix="/api", tags=["speaker-profiles"]) + + +@app.get("/") +async def root(): + return {"message": "Open Notebook API is running"} + + +@app.get("/health") +async def health(): + return {"status": "healthy"} diff --git a/api/models.py b/api/models.py new file mode 100644 index 0000000..a648ebf --- /dev/null +++ b/api/models.py @@ -0,0 +1,264 @@ +from typing import Any, Dict, List, Literal, Optional +from pydantic import BaseModel, Field, ConfigDict + + +# Notebook models +class NotebookCreate(BaseModel): + name: str = Field(..., description="Name of the notebook") + description: str = Field(default="", description="Description of the notebook") + + +class NotebookUpdate(BaseModel): + name: Optional[str] = Field(None, description="Name of the notebook") + description: Optional[str] = Field(None, description="Description of the notebook") + archived: Optional[bool] = Field(None, description="Whether the notebook is archived") + + +class NotebookResponse(BaseModel): + id: str + name: str + description: str + archived: bool + created: str + updated: str + + +# Search models +class SearchRequest(BaseModel): + query: str = Field(..., description="Search query") + type: Literal["text", "vector"] = Field("text", description="Search type") + limit: int = Field(100, description="Maximum number of results", le=1000) + search_sources: bool = Field(True, description="Include sources in search") + search_notes: bool = Field(True, description="Include notes in search") + minimum_score: float = Field(0.2, description="Minimum score for vector search", ge=0, le=1) + + +class SearchResponse(BaseModel): + results: List[Dict[str, Any]] = Field(..., description="Search results") + total_count: int = Field(..., description="Total number of results") + search_type: str = Field(..., description="Type of search performed") + + +class AskRequest(BaseModel): + question: str = Field(..., description="Question to ask the knowledge base") + strategy_model: str = Field(..., description="Model ID for query strategy") + answer_model: str = Field(..., description="Model ID for individual answers") + final_answer_model: str = Field(..., description="Model ID for final answer") + + +class AskResponse(BaseModel): + answer: str = Field(..., description="Final answer from the knowledge base") + question: str = Field(..., description="Original question") + + +# Models API models +class ModelCreate(BaseModel): + name: str = Field(..., description="Model name (e.g., gpt-4o-mini, claude, gemini)") + provider: str = Field(..., description="Provider name (e.g., openai, anthropic, gemini)") + type: str = Field(..., description="Model type (language, embedding, text_to_speech, speech_to_text)") + + +class ModelResponse(BaseModel): + id: str + name: str + provider: str + type: str + created: str + updated: str + + +class DefaultModelsResponse(BaseModel): + default_chat_model: Optional[str] = None + default_transformation_model: Optional[str] = None + large_context_model: Optional[str] = None + default_text_to_speech_model: Optional[str] = None + default_speech_to_text_model: Optional[str] = None + default_embedding_model: Optional[str] = None + default_tools_model: Optional[str] = None + + +# Transformations API models +class TransformationCreate(BaseModel): + name: str = Field(..., description="Transformation name") + title: str = Field(..., description="Display title for the transformation") + description: str = Field(..., description="Description of what this transformation does") + prompt: str = Field(..., description="The transformation prompt") + apply_default: bool = Field(False, description="Whether to apply this transformation by default") + + +class TransformationUpdate(BaseModel): + name: Optional[str] = Field(None, description="Transformation name") + title: Optional[str] = Field(None, description="Display title for the transformation") + description: Optional[str] = Field(None, description="Description of what this transformation does") + prompt: Optional[str] = Field(None, description="The transformation prompt") + apply_default: Optional[bool] = Field(None, description="Whether to apply this transformation by default") + + +class TransformationResponse(BaseModel): + id: str + name: str + title: str + description: str + prompt: str + apply_default: bool + created: str + updated: str + + +class TransformationExecuteRequest(BaseModel): + model_config = ConfigDict(protected_namespaces=()) + + transformation_id: str = Field(..., description="ID of the transformation to execute") + input_text: str = Field(..., description="Text to transform") + model_id: str = Field(..., description="Model ID to use for the transformation") + + +class TransformationExecuteResponse(BaseModel): + model_config = ConfigDict(protected_namespaces=()) + + output: str = Field(..., description="Transformed text") + transformation_id: str = Field(..., description="ID of the transformation used") + model_id: str = Field(..., description="Model ID used") + + +# Notes API models +class NoteCreate(BaseModel): + title: Optional[str] = Field(None, description="Note title") + content: str = Field(..., description="Note content") + note_type: Optional[str] = Field("human", description="Type of note (human, ai)") + notebook_id: Optional[str] = Field(None, description="Notebook ID to add the note to") + + +class NoteUpdate(BaseModel): + title: Optional[str] = Field(None, description="Note title") + content: Optional[str] = Field(None, description="Note content") + note_type: Optional[str] = Field(None, description="Type of note (human, ai)") + + +class NoteResponse(BaseModel): + id: str + title: Optional[str] + content: Optional[str] + note_type: Optional[str] + created: str + updated: str + + +# Embedding API models +class EmbedRequest(BaseModel): + item_id: str = Field(..., description="ID of the item to embed") + item_type: str = Field(..., description="Type of item (source, note)") + + +class EmbedResponse(BaseModel): + success: bool = Field(..., description="Whether embedding was successful") + message: str = Field(..., description="Result message") + item_id: str = Field(..., description="ID of the item that was embedded") + item_type: str = Field(..., description="Type of item that was embedded") + + +# Settings API models +class SettingsResponse(BaseModel): + default_content_processing_engine_doc: Optional[str] = None + default_content_processing_engine_url: Optional[str] = None + default_embedding_option: Optional[str] = None + auto_delete_files: Optional[str] = None + youtube_preferred_languages: Optional[List[str]] = None + + +class SettingsUpdate(BaseModel): + default_content_processing_engine_doc: Optional[str] = None + default_content_processing_engine_url: Optional[str] = None + default_embedding_option: Optional[str] = None + auto_delete_files: Optional[str] = None + youtube_preferred_languages: Optional[List[str]] = None + + +# Sources API models +class AssetModel(BaseModel): + file_path: Optional[str] = None + url: Optional[str] = None + + +class SourceCreate(BaseModel): + notebook_id: str = Field(..., description="Notebook ID to add the source to") + type: str = Field(..., description="Source type: link, upload, or text") + url: Optional[str] = Field(None, description="URL for link type") + file_path: Optional[str] = Field(None, description="File path for upload type") + content: Optional[str] = Field(None, description="Text content for text type") + title: Optional[str] = Field(None, description="Source title") + transformations: Optional[List[str]] = Field(default_factory=list, description="Transformation IDs to apply") + embed: bool = Field(False, description="Whether to embed content for vector search") + delete_source: bool = Field(False, description="Whether to delete uploaded file after processing") + + +class SourceUpdate(BaseModel): + title: Optional[str] = Field(None, description="Source title") + topics: Optional[List[str]] = Field(None, description="Source topics") + + +class SourceResponse(BaseModel): + id: str + title: Optional[str] + topics: Optional[List[str]] + asset: Optional[AssetModel] + full_text: Optional[str] + embedded_chunks: int + created: str + updated: str + + +class SourceListResponse(BaseModel): + id: str + title: Optional[str] + topics: Optional[List[str]] + asset: Optional[AssetModel] + embedded_chunks: int + insights_count: int + created: str + updated: str + + +# Context API models +class ContextConfig(BaseModel): + sources: Dict[str, str] = Field(default_factory=dict, description="Source inclusion config {source_id: level}") + notes: Dict[str, str] = Field(default_factory=dict, description="Note inclusion config {note_id: level}") + + +class ContextRequest(BaseModel): + notebook_id: str = Field(..., description="Notebook ID to get context for") + context_config: Optional[ContextConfig] = Field(None, description="Context configuration") + + +class ContextResponse(BaseModel): + notebook_id: str + sources: List[Dict[str, Any]] = Field(..., description="Source context data") + notes: List[Dict[str, Any]] = Field(..., description="Note context data") + total_tokens: Optional[int] = Field(None, description="Estimated token count") + + +# Insights API models +class SourceInsightResponse(BaseModel): + id: str + source_id: str + insight_type: str + content: str + created: str + updated: str + + +class SaveAsNoteRequest(BaseModel): + notebook_id: Optional[str] = Field(None, description="Notebook ID to add note to") + + +class CreateSourceInsightRequest(BaseModel): + model_config = ConfigDict(protected_namespaces=()) + + transformation_id: str = Field(..., description="ID of transformation to apply") + model_id: Optional[str] = Field(None, description="Model ID (uses default if not provided)") + + +# Error response +class ErrorResponse(BaseModel): + error: str + message: str \ No newline at end of file diff --git a/api/models_service.py b/api/models_service.py new file mode 100644 index 0000000..a6f5dcf --- /dev/null +++ b/api/models_service.py @@ -0,0 +1,97 @@ +""" +Models service layer using API. +""" + +from typing import Dict, List, Optional + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.models import DefaultModels, Model + + +class ModelsService: + """Service layer for models operations using API.""" + + def __init__(self): + logger.info("Using API for models operations") + + def get_all_models(self, model_type: Optional[str] = None) -> List[Model]: + """Get all models with optional type filtering.""" + models_data = api_client.get_models(model_type=model_type) + # Convert API response to Model objects + models = [] + for model_data in models_data: + model = Model( + name=model_data["name"], + provider=model_data["provider"], + type=model_data["type"], + ) + model.id = model_data["id"] + model.created = model_data["created"] + model.updated = model_data["updated"] + models.append(model) + return models + + def create_model(self, name: str, provider: str, model_type: str) -> Model: + """Create a new model.""" + model_data = api_client.create_model(name, provider, model_type) + model = Model( + name=model_data["name"], + provider=model_data["provider"], + type=model_data["type"], + ) + model.id = model_data["id"] + model.created = model_data["created"] + model.updated = model_data["updated"] + return model + + def delete_model(self, model_id: str) -> bool: + """Delete a model.""" + api_client.delete_model(model_id) + return True + + def get_default_models(self) -> DefaultModels: + """Get default model assignments.""" + defaults_data = api_client.get_default_models() + defaults = DefaultModels() + + # Set the values from API response + defaults.default_chat_model = defaults_data.get("default_chat_model") + defaults.default_transformation_model = defaults_data.get("default_transformation_model") + defaults.large_context_model = defaults_data.get("large_context_model") + defaults.default_text_to_speech_model = defaults_data.get("default_text_to_speech_model") + defaults.default_speech_to_text_model = defaults_data.get("default_speech_to_text_model") + defaults.default_embedding_model = defaults_data.get("default_embedding_model") + defaults.default_tools_model = defaults_data.get("default_tools_model") + + return defaults + + def update_default_models(self, defaults: DefaultModels) -> DefaultModels: + """Update default model assignments.""" + updates = { + "default_chat_model": defaults.default_chat_model, + "default_transformation_model": defaults.default_transformation_model, + "large_context_model": defaults.large_context_model, + "default_text_to_speech_model": defaults.default_text_to_speech_model, + "default_speech_to_text_model": defaults.default_speech_to_text_model, + "default_embedding_model": defaults.default_embedding_model, + "default_tools_model": defaults.default_tools_model, + } + + defaults_data = api_client.update_default_models(**updates) + + # Update the defaults object with the response + defaults.default_chat_model = defaults_data.get("default_chat_model") + defaults.default_transformation_model = defaults_data.get("default_transformation_model") + defaults.large_context_model = defaults_data.get("large_context_model") + defaults.default_text_to_speech_model = defaults_data.get("default_text_to_speech_model") + defaults.default_speech_to_text_model = defaults_data.get("default_speech_to_text_model") + defaults.default_embedding_model = defaults_data.get("default_embedding_model") + defaults.default_tools_model = defaults_data.get("default_tools_model") + + return defaults + + +# Global service instance +models_service = ModelsService() \ No newline at end of file diff --git a/api/notebook_service.py b/api/notebook_service.py new file mode 100644 index 0000000..f54cf96 --- /dev/null +++ b/api/notebook_service.py @@ -0,0 +1,84 @@ +""" +Notebook service layer using API. +""" + +from typing import List, Optional + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.notebook import Notebook + + +class NotebookService: + """Service layer for notebook operations using API.""" + + def __init__(self): + logger.info("Using API for notebook operations") + + def get_all_notebooks(self, order_by: str = "updated desc") -> List[Notebook]: + """Get all notebooks.""" + notebooks_data = api_client.get_notebooks(order_by=order_by) + # Convert API response to Notebook objects + notebooks = [] + for nb_data in notebooks_data: + nb = Notebook( + name=nb_data["name"], + description=nb_data["description"], + archived=nb_data["archived"], + ) + nb.id = nb_data["id"] + nb.created = nb_data["created"] + nb.updated = nb_data["updated"] + notebooks.append(nb) + return notebooks + + def get_notebook(self, notebook_id: str) -> Optional[Notebook]: + """Get a specific notebook.""" + nb_data = api_client.get_notebook(notebook_id) + nb = Notebook( + name=nb_data["name"], + description=nb_data["description"], + archived=nb_data["archived"], + ) + nb.id = nb_data["id"] + nb.created = nb_data["created"] + nb.updated = nb_data["updated"] + return nb + + def create_notebook(self, name: str, description: str = "") -> Notebook: + """Create a new notebook.""" + nb_data = api_client.create_notebook(name, description) + nb = Notebook( + name=nb_data["name"], + description=nb_data["description"], + archived=nb_data["archived"], + ) + nb.id = nb_data["id"] + nb.created = nb_data["created"] + nb.updated = nb_data["updated"] + return nb + + def update_notebook(self, notebook: Notebook) -> Notebook: + """Update a notebook.""" + updates = { + "name": notebook.name, + "description": notebook.description, + "archived": notebook.archived, + } + nb_data = api_client.update_notebook(notebook.id, **updates) + # Update the notebook object with the response + notebook.name = nb_data["name"] + notebook.description = nb_data["description"] + notebook.archived = nb_data["archived"] + notebook.updated = nb_data["updated"] + return notebook + + def delete_notebook(self, notebook: Notebook) -> bool: + """Delete a notebook.""" + api_client.delete_notebook(notebook.id) + return True + + +# Global service instance +notebook_service = NotebookService() \ No newline at end of file diff --git a/api/notes_service.py b/api/notes_service.py new file mode 100644 index 0000000..0e7344b --- /dev/null +++ b/api/notes_service.py @@ -0,0 +1,97 @@ +""" +Notes service layer using API. +""" + +from typing import Dict, List, Optional + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.notebook import Note + + +class NotesService: + """Service layer for notes operations using API.""" + + def __init__(self): + logger.info("Using API for notes operations") + + def get_all_notes(self, notebook_id: Optional[str] = None) -> List[Note]: + """Get all notes with optional notebook filtering.""" + notes_data = api_client.get_notes(notebook_id=notebook_id) + # Convert API response to Note objects + notes = [] + for note_data in notes_data: + note = Note( + title=note_data["title"], + content=note_data["content"], + note_type=note_data["note_type"], + ) + note.id = note_data["id"] + note.created = note_data["created"] + note.updated = note_data["updated"] + notes.append(note) + return notes + + def get_note(self, note_id: str) -> Note: + """Get a specific note.""" + note_data = api_client.get_note(note_id) + note = Note( + title=note_data["title"], + content=note_data["content"], + note_type=note_data["note_type"], + ) + note.id = note_data["id"] + note.created = note_data["created"] + note.updated = note_data["updated"] + return note + + def create_note( + self, + content: str, + title: Optional[str] = None, + note_type: str = "human", + notebook_id: Optional[str] = None + ) -> Note: + """Create a new note.""" + note_data = api_client.create_note( + content=content, + title=title, + note_type=note_type, + notebook_id=notebook_id + ) + note = Note( + title=note_data["title"], + content=note_data["content"], + note_type=note_data["note_type"], + ) + note.id = note_data["id"] + note.created = note_data["created"] + note.updated = note_data["updated"] + return note + + def update_note(self, note: Note) -> Note: + """Update a note.""" + updates = { + "title": note.title, + "content": note.content, + "note_type": note.note_type, + } + note_data = api_client.update_note(note.id, **updates) + + # Update the note object with the response + note.title = note_data["title"] + note.content = note_data["content"] + note.note_type = note_data["note_type"] + note.updated = note_data["updated"] + + return note + + def delete_note(self, note_id: str) -> bool: + """Delete a note.""" + api_client.delete_note(note_id) + return True + + +# Global service instance +notes_service = NotesService() \ No newline at end of file diff --git a/api/podcast_api_service.py b/api/podcast_api_service.py new file mode 100644 index 0000000..29a9f12 --- /dev/null +++ b/api/podcast_api_service.py @@ -0,0 +1,123 @@ +""" +Podcast service layer using API client. +This replaces direct httpx calls in the Streamlit pages. +""" + +from typing import Dict, List + +from loguru import logger + +from api.client import api_client + + +class PodcastAPIService: + """Service layer for podcast operations using API client.""" + + def __init__(self): + logger.info("Using API client for podcast operations") + + # Episode methods + def get_episodes(self) -> List[Dict]: + """Get all podcast episodes.""" + return api_client._make_request("GET", "/api/podcasts/episodes") + + def delete_episode(self, episode_id: str) -> bool: + """Delete a podcast episode.""" + try: + api_client._make_request("DELETE", f"/api/podcasts/episodes/{episode_id}") + return True + except Exception as e: + logger.error(f"Failed to delete episode: {e}") + return False + + # Episode Profile methods + def get_episode_profiles(self) -> List[Dict]: + """Get all episode profiles.""" + return api_client.get_episode_profiles() + + def create_episode_profile(self, profile_data: Dict) -> bool: + """Create a new episode profile.""" + try: + api_client.create_episode_profile(**profile_data) + return True + except Exception as e: + logger.error(f"Failed to create episode profile: {e}") + return False + + def update_episode_profile(self, profile_id: str, profile_data: Dict) -> bool: + """Update an episode profile.""" + try: + api_client.update_episode_profile(profile_id, **profile_data) + return True + except Exception as e: + logger.error(f"Failed to update episode profile: {e}") + return False + + def delete_episode_profile(self, profile_id: str) -> bool: + """Delete an episode profile.""" + try: + api_client.delete_episode_profile(profile_id) + return True + except Exception as e: + logger.error(f"Failed to delete episode profile: {e}") + return False + + def duplicate_episode_profile(self, profile_id: str) -> bool: + """Duplicate an episode profile.""" + try: + api_client._make_request( + "POST", f"/api/episode-profiles/{profile_id}/duplicate" + ) + return True + except Exception as e: + logger.error(f"Failed to duplicate episode profile: {e}") + return False + + # Speaker Profile methods + def get_speaker_profiles(self) -> List[Dict]: + """Get all speaker profiles.""" + return api_client._make_request("GET", "/api/speaker-profiles") + + def create_speaker_profile(self, profile_data: Dict) -> bool: + """Create a new speaker profile.""" + try: + api_client._make_request("POST", "/api/speaker-profiles", json=profile_data) + return True + except Exception as e: + logger.error(f"Failed to create speaker profile: {e}") + return False + + def update_speaker_profile(self, profile_id: str, profile_data: Dict) -> bool: + """Update a speaker profile.""" + try: + api_client._make_request( + "PUT", f"/api/speaker-profiles/{profile_id}", json=profile_data + ) + return True + except Exception as e: + logger.error(f"Failed to update speaker profile: {e}") + return False + + def delete_speaker_profile(self, profile_id: str) -> bool: + """Delete a speaker profile.""" + try: + api_client._make_request("DELETE", f"/api/speaker-profiles/{profile_id}") + return True + except Exception as e: + logger.error(f"Failed to delete speaker profile: {e}") + return False + + def duplicate_speaker_profile(self, profile_id: str) -> bool: + """Duplicate a speaker profile.""" + try: + api_client._make_request( + "POST", f"/api/speaker-profiles/{profile_id}/duplicate" + ) + return True + except Exception as e: + logger.error(f"Failed to duplicate speaker profile: {e}") + return False + + +# Global service instance +podcast_api_service = PodcastAPIService() diff --git a/api/podcast_service.py b/api/podcast_service.py new file mode 100644 index 0000000..3041fe1 --- /dev/null +++ b/api/podcast_service.py @@ -0,0 +1,204 @@ +from typing import Any, Dict, Optional + +from fastapi import HTTPException +from loguru import logger +from pydantic import BaseModel +from surreal_commands import get_command_status, submit_command + +from open_notebook.domain.notebook import Notebook +from open_notebook.domain.podcast import EpisodeProfile, PodcastEpisode, SpeakerProfile + + +class PodcastGenerationRequest(BaseModel): + """Request model for podcast generation""" + + episode_profile: str + speaker_profile: str + episode_name: str + content: Optional[str] = None + notebook_id: Optional[str] = None + briefing_suffix: Optional[str] = None + + +class PodcastGenerationResponse(BaseModel): + """Response model for podcast generation""" + + job_id: str + status: str + message: str + episode_profile: str + episode_name: str + + +class PodcastService: + """Service layer for podcast operations""" + + @staticmethod + async def submit_generation_job( + episode_profile_name: str, + speaker_profile_name: str, + episode_name: str, + notebook_id: Optional[str] = None, + content: Optional[str] = None, + briefing_suffix: Optional[str] = None, + ) -> str: + """Submit a podcast generation job for background processing""" + try: + # Validate episode profile exists + episode_profile = await EpisodeProfile.get_by_name(episode_profile_name) + if not episode_profile: + raise ValueError(f"Episode profile '{episode_profile_name}' not found") + + # Validate speaker profile exists + speaker_profile = await SpeakerProfile.get_by_name(speaker_profile_name) + if not speaker_profile: + raise ValueError(f"Speaker profile '{speaker_profile_name}' not found") + + # Get content from notebook if not provided directly + if not content and notebook_id: + try: + notebook = await Notebook.get(notebook_id) + # Get notebook context (this may need to be adjusted based on actual Notebook implementation) + content = ( + await notebook.get_context() + if hasattr(notebook, "get_context") + else str(notebook) + ) + except Exception as e: + logger.warning( + f"Failed to get notebook content, using notebook_id as content: {e}" + ) + content = f"Notebook ID: {notebook_id}" + + if not content: + raise ValueError( + "Content is required - provide either content or notebook_id" + ) + + # Prepare command arguments + command_args = { + "episode_profile": episode_profile_name, + "speaker_profile": speaker_profile_name, + "episode_name": episode_name, + "content": str(content), + "briefing_suffix": briefing_suffix, + } + + # Ensure command modules are imported before submitting + # This is needed because submit_command validates against local registry + try: + import commands.podcast_commands # noqa: F401 + except ImportError as import_err: + logger.error(f"Failed to import podcast commands: {import_err}") + raise ValueError("Podcast commands not available") + + # Submit command to surreal-commands + job_id = submit_command("open_notebook", "generate_podcast", command_args) + + # Convert RecordID to string if needed + job_id_str = str(job_id) if job_id else None + logger.info( + f"Submitted podcast generation job: {job_id_str} for episode '{episode_name}'" + ) + return job_id_str + + except Exception as e: + logger.error(f"Failed to submit podcast generation job: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to submit podcast generation job: {str(e)}", + ) + + @staticmethod + async def get_job_status(job_id: str) -> Dict[str, Any]: + """Get status of a podcast generation job""" + try: + status = await get_command_status(job_id) + return { + "job_id": job_id, + "status": status.status if status else "unknown", + "result": status.result if status else None, + "error_message": getattr(status, "error_message", None) + if status + else None, + "created": str(status.created) + if status and hasattr(status, "created") and status.created + else None, + "updated": str(status.updated) + if status and hasattr(status, "updated") and status.updated + else None, + "progress": getattr(status, "progress", None) if status else None, + } + except Exception as e: + logger.error(f"Failed to get podcast job status: {e}") + raise HTTPException( + status_code=500, detail=f"Failed to get job status: {str(e)}" + ) + + @staticmethod + async def list_episodes() -> list: + """List all podcast episodes""" + try: + episodes = await PodcastEpisode.get_all(order_by="created desc") + return episodes + except Exception as e: + logger.error(f"Failed to list podcast episodes: {e}") + raise HTTPException( + status_code=500, detail=f"Failed to list episodes: {str(e)}" + ) + + @staticmethod + async def get_episode(episode_id: str) -> PodcastEpisode: + """Get a specific podcast episode""" + try: + episode = await PodcastEpisode.get(episode_id) + return episode + except Exception as e: + logger.error(f"Failed to get podcast episode {episode_id}: {e}") + raise HTTPException(status_code=404, detail=f"Episode not found: {str(e)}") + + +class DefaultProfiles: + """Utility class for creating default profiles (if needed beyond migration data)""" + + @staticmethod + async def create_default_episode_profiles(): + """Create default episode profiles if they don't exist""" + try: + # Check if profiles already exist + existing = await EpisodeProfile.get_all() + if existing: + logger.info(f"Episode profiles already exist: {len(existing)} found") + return existing + + # This would create profiles, but since we have migration data, + # this is mainly for future extensibility + logger.info( + "Default episode profiles should be created via database migration" + ) + return [] + + except Exception as e: + logger.error(f"Failed to create default episode profiles: {e}") + raise + + @staticmethod + async def create_default_speaker_profiles(): + """Create default speaker profiles if they don't exist""" + try: + # Check if profiles already exist + existing = await SpeakerProfile.get_all() + if existing: + logger.info(f"Speaker profiles already exist: {len(existing)} found") + return existing + + # This would create profiles, but since we have migration data, + # this is mainly for future extensibility + logger.info( + "Default speaker profiles should be created via database migration" + ) + return [] + + except Exception as e: + logger.error(f"Failed to create default speaker profiles: {e}") + raise diff --git a/api/routers/__init__.py b/api/routers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/api/routers/commands.py b/api/routers/commands.py new file mode 100644 index 0000000..c386c57 --- /dev/null +++ b/api/routers/commands.py @@ -0,0 +1,160 @@ +from typing import List, Optional, Dict, Any +from fastapi import APIRouter, HTTPException, Query +from pydantic import BaseModel, Field +from loguru import logger + +from api.command_service import CommandService +from api.models import ErrorResponse +from surreal_commands import registry + +router = APIRouter() + +class CommandExecutionRequest(BaseModel): + command: str = Field(..., description="Command function name (e.g., 'process_text')") + app: str = Field(..., description="Application name (e.g., 'open_notebook')") + input: Dict[str, Any] = Field(..., description="Arguments to pass to the command") + +class CommandJobResponse(BaseModel): + job_id: str + status: str + message: str + +class CommandJobStatusResponse(BaseModel): + job_id: str + status: str + result: Optional[Dict[str, Any]] = None + error_message: Optional[str] = None + created: Optional[str] = None + updated: Optional[str] = None + progress: Optional[Dict[str, Any]] = None + +@router.post("/commands/jobs", response_model=CommandJobResponse) +async def execute_command(request: CommandExecutionRequest): + """ + Submit a command for background processing. + Returns immediately with job ID for status tracking. + + Example request: + { + "command": "process_text", + "app": "open_notebook", + "input": { + "text": "Hello world", + "operation": "uppercase" + } + } + """ + try: + # Submit command using app name (not module name) + job_id = await CommandService.submit_command_job( + module_name=request.app, # This should be "open_notebook" + command_name=request.command, + command_args=request.input + ) + + return CommandJobResponse( + job_id=job_id, + status="submitted", + message=f"Command '{request.command}' submitted successfully" + ) + + except Exception as e: + logger.error(f"Error submitting command: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to submit command: {str(e)}" + ) + +@router.get("/commands/jobs/{job_id}", response_model=CommandJobStatusResponse) +async def get_command_job_status(job_id: str): + """Get the status of a specific command job""" + try: + status_data = await CommandService.get_command_status(job_id) + return CommandJobStatusResponse(**status_data) + + except Exception as e: + logger.error(f"Error fetching job status: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to fetch job status: {str(e)}" + ) + +@router.get("/commands/jobs", response_model=List[Dict[str, Any]]) +async def list_command_jobs( + command_filter: Optional[str] = Query(None, description="Filter by command name"), + status_filter: Optional[str] = Query(None, description="Filter by status"), + limit: int = Query(50, description="Maximum number of jobs to return") +): + """List command jobs with optional filtering""" + try: + jobs = await CommandService.list_command_jobs( + command_filter=command_filter, + status_filter=status_filter, + limit=limit + ) + return jobs + + except Exception as e: + logger.error(f"Error listing command jobs: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to list command jobs: {str(e)}" + ) + +@router.delete("/commands/jobs/{job_id}") +async def cancel_command_job(job_id: str): + """Cancel a running command job""" + try: + success = await CommandService.cancel_command_job(job_id) + return {"job_id": job_id, "cancelled": success} + + except Exception as e: + logger.error(f"Error cancelling command job: {str(e)}") + raise HTTPException( + status_code=500, + detail=f"Failed to cancel command job: {str(e)}" + ) + +@router.get("/commands/registry/debug") +async def debug_registry(): + """Debug endpoint to see what commands are registered""" + try: + # Get all registered commands + all_items = registry.get_all_commands() + + # Create JSON-serializable data + command_items = [] + for item in all_items: + try: + command_items.append({ + "app_id": item.app_id, + "name": item.name, + "full_id": f"{item.app_id}.{item.name}" + }) + except Exception as item_error: + logger.error(f"Error processing item: {item_error}") + + # Get the basic command structure + try: + commands_dict = {} + for item in all_items: + if item.app_id not in commands_dict: + commands_dict[item.app_id] = [] + commands_dict[item.app_id].append(item.name) + except Exception: + commands_dict = {} + + return { + "total_commands": len(all_items), + "commands_by_app": commands_dict, + "command_items": command_items + } + + except Exception as e: + logger.error(f"Error debugging registry: {str(e)}") + return { + "error": str(e), + "total_commands": 0, + "commands_by_app": {}, + "command_items": [] + } \ No newline at end of file diff --git a/api/routers/context.py b/api/routers/context.py new file mode 100644 index 0000000..29e56e2 --- /dev/null +++ b/api/routers/context.py @@ -0,0 +1,118 @@ +from typing import Dict, List, Union + +from fastapi import APIRouter, HTTPException +from loguru import logger + +from api.models import ContextRequest, ContextResponse +from open_notebook.domain.base import ObjectModel +from open_notebook.domain.notebook import Note, Notebook, Source +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError +from open_notebook.utils import token_count + +router = APIRouter() + + +@router.post("/notebooks/{notebook_id}/context", response_model=ContextResponse) +async def get_notebook_context(notebook_id: str, context_request: ContextRequest): + """Get context for a notebook based on configuration.""" + try: + # Verify notebook exists + notebook = await Notebook.get(notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + + context_data = {"note": [], "source": []} + total_content = "" + + # Process context configuration if provided + if context_request.context_config: + # Process sources + for source_id, status in context_request.context_config.sources.items(): + if "not in" in status: + continue + + try: + # Add table prefix if not present + full_source_id = ( + source_id + if source_id.startswith("source:") + else f"source:{source_id}" + ) + + try: + source = await Source.get(full_source_id) + except Exception as e: + continue + + if "insights" in status: + source_context = await source.get_context(context_size="short") + context_data["source"].append(source_context) + total_content += str(source_context) + elif "full content" in status: + source_context = await source.get_context(context_size="long") + context_data["source"].append(source_context) + total_content += str(source_context) + except Exception as e: + logger.warning(f"Error processing source {source_id}: {str(e)}") + continue + + # Process notes + for note_id, status in context_request.context_config.notes.items(): + if "not in" in status: + continue + + try: + # Add table prefix if not present + full_note_id = ( + note_id if note_id.startswith("note:") else f"note:{note_id}" + ) + note = await Note.get(full_note_id) + if not note: + continue + + if "full content" in status: + note_context = note.get_context(context_size="long") + context_data["note"].append(note_context) + total_content += str(note_context) + except Exception as e: + logger.warning(f"Error processing note {note_id}: {str(e)}") + continue + else: + # Default behavior - include all sources and notes with short context + sources = await notebook.get_sources() + for source in sources: + try: + source_context = await source.get_context(context_size="short") + context_data["source"].append(source_context) + total_content += str(source_context) + except Exception as e: + logger.warning(f"Error processing source {source.id}: {str(e)}") + continue + + notes = await notebook.get_notes() + for note in notes: + try: + note_context = note.get_context(context_size="short") + context_data["note"].append(note_context) + total_content += str(note_context) + except Exception as e: + logger.warning(f"Error processing note {note.id}: {str(e)}") + continue + + # Calculate estimated token count + estimated_tokens = token_count(total_content) if total_content else 0 + + return ContextResponse( + notebook_id=notebook_id, + sources=context_data["source"], + notes=context_data["note"], + total_tokens=estimated_tokens, + ) + + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error getting context for notebook {notebook_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error getting context: {str(e)}") diff --git a/api/routers/embedding.py b/api/routers/embedding.py new file mode 100644 index 0000000..017d6ac --- /dev/null +++ b/api/routers/embedding.py @@ -0,0 +1,69 @@ +from fastapi import APIRouter, HTTPException +from loguru import logger + +from api.models import EmbedRequest, EmbedResponse +from open_notebook.domain.models import model_manager +from open_notebook.domain.notebook import Note, Source + +router = APIRouter() + + +@router.post("/embed", response_model=EmbedResponse) +async def embed_content(embed_request: EmbedRequest): + """Embed content for vector search.""" + try: + # Check if embedding model is available + if not await model_manager.get_embedding_model(): + raise HTTPException( + status_code=400, + detail="No embedding model configured. Please configure one in the Models section.", + ) + + item_id = embed_request.item_id + item_type = embed_request.item_type.lower() + + # Validate item type + if item_type not in ["source", "note"]: + raise HTTPException( + status_code=400, detail="Item type must be either 'source' or 'note'" + ) + + # Get the item and embed it + if item_type == "source": + source_item = await Source.get(item_id) + if not source_item: + raise HTTPException(status_code=404, detail="Source not found") + + # Check if already embedded + if await source_item.get_embedded_chunks() > 0: + return EmbedResponse( + success=True, + message="Source is already embedded", + item_id=item_id, + item_type=item_type, + ) + + # Perform embedding + await source_item.vectorize() + message = "Source embedded successfully" + + elif item_type == "note": + note_item = await Note.get(item_id) + if not note_item: + raise HTTPException(status_code=404, detail="Note not found") + + await note_item.vectorize() + + return EmbedResponse( + success=True, message=message, item_id=item_id, item_type=item_type + ) + + except HTTPException: + raise + except Exception as e: + logger.error( + f"Error embedding {embed_request.item_type} {embed_request.item_id}: {str(e)}" + ) + raise HTTPException( + status_code=500, detail=f"Error embedding content: {str(e)}" + ) diff --git a/api/routers/episode_profiles.py b/api/routers/episode_profiles.py new file mode 100644 index 0000000..45a3af5 --- /dev/null +++ b/api/routers/episode_profiles.py @@ -0,0 +1,262 @@ +from typing import List +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel, Field +from loguru import logger + +from open_notebook.domain.podcast import EpisodeProfile + + +router = APIRouter() + + +class EpisodeProfileResponse(BaseModel): + id: str + name: str + description: str + speaker_config: str + outline_provider: str + outline_model: str + transcript_provider: str + transcript_model: str + default_briefing: str + num_segments: int + + +@router.get("/episode-profiles", response_model=List[EpisodeProfileResponse]) +async def list_episode_profiles(): + """List all available episode profiles""" + try: + profiles = await EpisodeProfile.get_all(order_by="name asc") + + return [ + EpisodeProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + speaker_config=profile.speaker_config, + outline_provider=profile.outline_provider, + outline_model=profile.outline_model, + transcript_provider=profile.transcript_provider, + transcript_model=profile.transcript_model, + default_briefing=profile.default_briefing, + num_segments=profile.num_segments + ) + for profile in profiles + ] + + except Exception as e: + logger.error(f"Failed to fetch episode profiles: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to fetch episode profiles: {str(e)}" + ) + + +@router.get("/episode-profiles/{profile_name}", response_model=EpisodeProfileResponse) +async def get_episode_profile(profile_name: str): + """Get a specific episode profile by name""" + try: + profile = await EpisodeProfile.get_by_name(profile_name) + + if not profile: + raise HTTPException( + status_code=404, + detail=f"Episode profile '{profile_name}' not found" + ) + + return EpisodeProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + speaker_config=profile.speaker_config, + outline_provider=profile.outline_provider, + outline_model=profile.outline_model, + transcript_provider=profile.transcript_provider, + transcript_model=profile.transcript_model, + default_briefing=profile.default_briefing, + num_segments=profile.num_segments + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to fetch episode profile '{profile_name}': {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to fetch episode profile: {str(e)}" + ) + + +class EpisodeProfileCreate(BaseModel): + name: str = Field(..., description="Unique profile name") + description: str = Field("", description="Profile description") + speaker_config: str = Field(..., description="Reference to speaker profile name") + outline_provider: str = Field(..., description="AI provider for outline generation") + outline_model: str = Field(..., description="AI model for outline generation") + transcript_provider: str = Field(..., description="AI provider for transcript generation") + transcript_model: str = Field(..., description="AI model for transcript generation") + default_briefing: str = Field(..., description="Default briefing template") + num_segments: int = Field(default=5, description="Number of podcast segments") + + +@router.post("/episode-profiles", response_model=EpisodeProfileResponse) +async def create_episode_profile(profile_data: EpisodeProfileCreate): + """Create a new episode profile""" + try: + profile = EpisodeProfile( + name=profile_data.name, + description=profile_data.description, + speaker_config=profile_data.speaker_config, + outline_provider=profile_data.outline_provider, + outline_model=profile_data.outline_model, + transcript_provider=profile_data.transcript_provider, + transcript_model=profile_data.transcript_model, + default_briefing=profile_data.default_briefing, + num_segments=profile_data.num_segments + ) + + await profile.save() + + return EpisodeProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + speaker_config=profile.speaker_config, + outline_provider=profile.outline_provider, + outline_model=profile.outline_model, + transcript_provider=profile.transcript_provider, + transcript_model=profile.transcript_model, + default_briefing=profile.default_briefing, + num_segments=profile.num_segments + ) + + except Exception as e: + logger.error(f"Failed to create episode profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to create episode profile: {str(e)}" + ) + + +@router.put("/episode-profiles/{profile_id}", response_model=EpisodeProfileResponse) +async def update_episode_profile(profile_id: str, profile_data: EpisodeProfileCreate): + """Update an existing episode profile""" + try: + profile = await EpisodeProfile.get(profile_id) + + if not profile: + raise HTTPException( + status_code=404, + detail=f"Episode profile '{profile_id}' not found" + ) + + # Update fields + profile.name = profile_data.name + profile.description = profile_data.description + profile.speaker_config = profile_data.speaker_config + profile.outline_provider = profile_data.outline_provider + profile.outline_model = profile_data.outline_model + profile.transcript_provider = profile_data.transcript_provider + profile.transcript_model = profile_data.transcript_model + profile.default_briefing = profile_data.default_briefing + profile.num_segments = profile_data.num_segments + + await profile.save() + + return EpisodeProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + speaker_config=profile.speaker_config, + outline_provider=profile.outline_provider, + outline_model=profile.outline_model, + transcript_provider=profile.transcript_provider, + transcript_model=profile.transcript_model, + default_briefing=profile.default_briefing, + num_segments=profile.num_segments + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to update episode profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to update episode profile: {str(e)}" + ) + + +@router.delete("/episode-profiles/{profile_id}") +async def delete_episode_profile(profile_id: str): + """Delete an episode profile""" + try: + profile = await EpisodeProfile.get(profile_id) + + if not profile: + raise HTTPException( + status_code=404, + detail=f"Episode profile '{profile_id}' not found" + ) + + await profile.delete() + + return {"message": "Episode profile deleted successfully"} + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to delete episode profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to delete episode profile: {str(e)}" + ) + + +@router.post("/episode-profiles/{profile_id}/duplicate", response_model=EpisodeProfileResponse) +async def duplicate_episode_profile(profile_id: str): + """Duplicate an episode profile""" + try: + original = await EpisodeProfile.get(profile_id) + + if not original: + raise HTTPException( + status_code=404, + detail=f"Episode profile '{profile_id}' not found" + ) + + # Create duplicate with modified name + duplicate = EpisodeProfile( + name=f"{original.name} - Copy", + description=original.description, + speaker_config=original.speaker_config, + outline_provider=original.outline_provider, + outline_model=original.outline_model, + transcript_provider=original.transcript_provider, + transcript_model=original.transcript_model, + default_briefing=original.default_briefing, + num_segments=original.num_segments + ) + + await duplicate.save() + + return EpisodeProfileResponse( + id=str(duplicate.id), + name=duplicate.name, + description=duplicate.description or "", + speaker_config=duplicate.speaker_config, + outline_provider=duplicate.outline_provider, + outline_model=duplicate.outline_model, + transcript_provider=duplicate.transcript_provider, + transcript_model=duplicate.transcript_model, + default_briefing=duplicate.default_briefing, + num_segments=duplicate.num_segments + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to duplicate episode profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to duplicate episode profile: {str(e)}" + ) \ No newline at end of file diff --git a/api/routers/insights.py b/api/routers/insights.py new file mode 100644 index 0000000..890ff5d --- /dev/null +++ b/api/routers/insights.py @@ -0,0 +1,82 @@ +from typing import Optional + +from fastapi import APIRouter, HTTPException +from loguru import logger + +from api.models import NoteResponse, SaveAsNoteRequest, SourceInsightResponse +from open_notebook.domain.notebook import Note, SourceInsight +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError + +router = APIRouter() + + +@router.get("/insights/{insight_id}", response_model=SourceInsightResponse) +async def get_insight(insight_id: str): + """Get a specific insight by ID.""" + try: + insight = await SourceInsight.get(insight_id) + if not insight: + raise HTTPException(status_code=404, detail="Insight not found") + + # Get source ID from the insight relationship + source = await insight.get_source() + + return SourceInsightResponse( + id=insight.id, + source_id=source.id, + insight_type=insight.insight_type, + content=insight.content, + created=str(insight.created), + updated=str(insight.updated), + ) + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching insight {insight_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching insight: {str(e)}") + + +@router.delete("/insights/{insight_id}") +async def delete_insight(insight_id: str): + """Delete a specific insight.""" + try: + insight = await SourceInsight.get(insight_id) + if not insight: + raise HTTPException(status_code=404, detail="Insight not found") + + await insight.delete() + + return {"message": "Insight deleted successfully"} + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting insight {insight_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error deleting insight: {str(e)}") + + +@router.post("/insights/{insight_id}/save-as-note", response_model=NoteResponse) +async def save_insight_as_note(insight_id: str, request: SaveAsNoteRequest): + """Convert an insight to a note.""" + try: + insight = await SourceInsight.get(insight_id) + if not insight: + raise HTTPException(status_code=404, detail="Insight not found") + + # Use the existing save_as_note method from the domain model + note = await insight.save_as_note(request.notebook_id) + + return NoteResponse( + id=note.id, + title=note.title, + content=note.content, + note_type=note.note_type, + created=str(note.created), + updated=str(note.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error saving insight {insight_id} as note: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error saving insight as note: {str(e)}") \ No newline at end of file diff --git a/api/routers/models.py b/api/routers/models.py new file mode 100644 index 0000000..d82e046 --- /dev/null +++ b/api/routers/models.py @@ -0,0 +1,153 @@ +from typing import List, Optional + +from fastapi import APIRouter, HTTPException, Query +from loguru import logger + +from api.models import DefaultModelsResponse, ModelCreate, ModelResponse +from open_notebook.domain.models import DefaultModels, Model +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError + +router = APIRouter() + + +@router.get("/models", response_model=List[ModelResponse]) +async def get_models( + type: Optional[str] = Query(None, description="Filter by model type") +): + """Get all configured models with optional type filtering.""" + try: + if type: + models = await Model.get_models_by_type(type) + else: + models = await Model.get_all() + + return [ + ModelResponse( + id=model.id, + name=model.name, + provider=model.provider, + type=model.type, + created=str(model.created), + updated=str(model.updated), + ) + for model in models + ] + except Exception as e: + logger.error(f"Error fetching models: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching models: {str(e)}") + + +@router.post("/models", response_model=ModelResponse) +async def create_model(model_data: ModelCreate): + """Create a new model configuration.""" + try: + # Validate model type + valid_types = ["language", "embedding", "text_to_speech", "speech_to_text"] + if model_data.type not in valid_types: + raise HTTPException( + status_code=400, + detail=f"Invalid model type. Must be one of: {valid_types}" + ) + + new_model = Model( + name=model_data.name, + provider=model_data.provider, + type=model_data.type, + ) + await new_model.save() + + return ModelResponse( + id=new_model.id, + name=new_model.name, + provider=new_model.provider, + type=new_model.type, + created=str(new_model.created), + updated=str(new_model.updated), + ) + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error creating model: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error creating model: {str(e)}") + + +@router.delete("/models/{model_id}") +async def delete_model(model_id: str): + """Delete a model configuration.""" + try: + model = await Model.get(model_id) + if not model: + raise HTTPException(status_code=404, detail="Model not found") + + await model.delete() + + return {"message": "Model deleted successfully"} + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting model {model_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error deleting model: {str(e)}") + + +@router.get("/models/defaults", response_model=DefaultModelsResponse) +async def get_default_models(): + """Get default model assignments.""" + try: + defaults = await DefaultModels.get_instance() + + return DefaultModelsResponse( + default_chat_model=defaults.default_chat_model, + default_transformation_model=defaults.default_transformation_model, + large_context_model=defaults.large_context_model, + default_text_to_speech_model=defaults.default_text_to_speech_model, + default_speech_to_text_model=defaults.default_speech_to_text_model, + default_embedding_model=defaults.default_embedding_model, + default_tools_model=defaults.default_tools_model, + ) + except Exception as e: + logger.error(f"Error fetching default models: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching default models: {str(e)}") + + +@router.put("/models/defaults", response_model=DefaultModelsResponse) +async def update_default_models(defaults_data: DefaultModelsResponse): + """Update default model assignments.""" + try: + defaults = await DefaultModels.get_instance() + + # Update only provided fields + if defaults_data.default_chat_model is not None: + defaults.default_chat_model = defaults_data.default_chat_model + if defaults_data.default_transformation_model is not None: + defaults.default_transformation_model = defaults_data.default_transformation_model + if defaults_data.large_context_model is not None: + defaults.large_context_model = defaults_data.large_context_model + if defaults_data.default_text_to_speech_model is not None: + defaults.default_text_to_speech_model = defaults_data.default_text_to_speech_model + if defaults_data.default_speech_to_text_model is not None: + defaults.default_speech_to_text_model = defaults_data.default_speech_to_text_model + if defaults_data.default_embedding_model is not None: + defaults.default_embedding_model = defaults_data.default_embedding_model + if defaults_data.default_tools_model is not None: + defaults.default_tools_model = defaults_data.default_tools_model + + await defaults.update() + + # Refresh the model manager cache + from open_notebook.domain.models import model_manager + await model_manager.refresh_defaults() + + return DefaultModelsResponse( + default_chat_model=defaults.default_chat_model, + default_transformation_model=defaults.default_transformation_model, + large_context_model=defaults.large_context_model, + default_text_to_speech_model=defaults.default_text_to_speech_model, + default_speech_to_text_model=defaults.default_speech_to_text_model, + default_embedding_model=defaults.default_embedding_model, + default_tools_model=defaults.default_tools_model, + ) + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating default models: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error updating default models: {str(e)}") \ No newline at end of file diff --git a/api/routers/notebooks.py b/api/routers/notebooks.py new file mode 100644 index 0000000..3681b59 --- /dev/null +++ b/api/routers/notebooks.py @@ -0,0 +1,140 @@ +from typing import List, Optional + +from fastapi import APIRouter, HTTPException, Query +from loguru import logger + +from api.models import ErrorResponse, NotebookCreate, NotebookResponse, NotebookUpdate +from open_notebook.domain.notebook import Notebook +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError + +router = APIRouter() + + +@router.get("/notebooks", response_model=List[NotebookResponse]) +async def get_notebooks( + archived: Optional[bool] = Query(None, description="Filter by archived status"), + order_by: str = Query("updated desc", description="Order by field and direction"), +): + """Get all notebooks with optional filtering and ordering.""" + try: + notebooks = await Notebook.get_all(order_by=order_by) + + # Filter by archived status if specified + if archived is not None: + notebooks = [nb for nb in notebooks if nb.archived == archived] + + return [ + NotebookResponse( + id=nb.id, + name=nb.name, + description=nb.description, + archived=nb.archived or False, + created=str(nb.created), + updated=str(nb.updated), + ) + for nb in notebooks + ] + except Exception as e: + logger.error(f"Error fetching notebooks: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching notebooks: {str(e)}") + + +@router.post("/notebooks", response_model=NotebookResponse) +async def create_notebook(notebook: NotebookCreate): + """Create a new notebook.""" + try: + new_notebook = Notebook( + name=notebook.name, + description=notebook.description, + ) + await new_notebook.save() + + return NotebookResponse( + id=new_notebook.id, + name=new_notebook.name, + description=new_notebook.description, + archived=new_notebook.archived or False, + created=str(new_notebook.created), + updated=str(new_notebook.updated), + ) + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error creating notebook: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error creating notebook: {str(e)}") + + +@router.get("/notebooks/{notebook_id}", response_model=NotebookResponse) +async def get_notebook(notebook_id: str): + """Get a specific notebook by ID.""" + try: + notebook = await Notebook.get(notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + + return NotebookResponse( + id=notebook.id, + name=notebook.name, + description=notebook.description, + archived=notebook.archived or False, + created=str(notebook.created), + updated=str(notebook.updated), + ) + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching notebook {notebook_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching notebook: {str(e)}") + + +@router.put("/notebooks/{notebook_id}", response_model=NotebookResponse) +async def update_notebook(notebook_id: str, notebook_update: NotebookUpdate): + """Update a notebook.""" + try: + notebook = await Notebook.get(notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + + # Update only provided fields + if notebook_update.name is not None: + notebook.name = notebook_update.name + if notebook_update.description is not None: + notebook.description = notebook_update.description + if notebook_update.archived is not None: + notebook.archived = notebook_update.archived + + await notebook.save() + + return NotebookResponse( + id=notebook.id, + name=notebook.name, + description=notebook.description, + archived=notebook.archived or False, + created=str(notebook.created), + updated=str(notebook.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error updating notebook {notebook_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error updating notebook: {str(e)}") + + +@router.delete("/notebooks/{notebook_id}") +async def delete_notebook(notebook_id: str): + """Delete a notebook.""" + try: + notebook = await Notebook.get(notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + + await notebook.delete() + + return {"message": "Notebook deleted successfully"} + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting notebook {notebook_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error deleting notebook: {str(e)}") \ No newline at end of file diff --git a/api/routers/notes.py b/api/routers/notes.py new file mode 100644 index 0000000..33f9826 --- /dev/null +++ b/api/routers/notes.py @@ -0,0 +1,168 @@ +from typing import List, Optional + +from fastapi import APIRouter, HTTPException, Query +from loguru import logger + +from api.models import NoteCreate, NoteResponse, NoteUpdate +from open_notebook.domain.notebook import Note +from open_notebook.exceptions import InvalidInputError + +router = APIRouter() + + +@router.get("/notes", response_model=List[NoteResponse]) +async def get_notes( + notebook_id: Optional[str] = Query(None, description="Filter by notebook ID") +): + """Get all notes with optional notebook filtering.""" + try: + if notebook_id: + # Get notes for a specific notebook + from open_notebook.domain.notebook import Notebook + notebook = await Notebook.get(notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + notes = await notebook.get_notes() + else: + # Get all notes + notes = await Note.get_all(order_by="updated desc") + + return [ + NoteResponse( + id=note.id, + title=note.title, + content=note.content, + note_type=note.note_type, + created=str(note.created), + updated=str(note.updated), + ) + for note in notes + ] + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching notes: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching notes: {str(e)}") + + +@router.post("/notes", response_model=NoteResponse) +async def create_note(note_data: NoteCreate): + """Create a new note.""" + try: + # Auto-generate title if not provided and it's an AI note + title = note_data.title + if not title and note_data.note_type == "ai" and note_data.content: + from open_notebook.graphs.prompt import graph as prompt_graph + prompt = "Based on the Note below, please provide a Title for this content, with max 15 words" + result = await prompt_graph.ainvoke({ + "input_text": note_data.content, + "prompt": prompt + }) + title = result.get("output", "Untitled Note") + + new_note = Note( + title=title, + content=note_data.content, + note_type=note_data.note_type, + ) + await new_note.save() + + # Add to notebook if specified + if note_data.notebook_id: + from open_notebook.domain.notebook import Notebook + notebook = await Notebook.get(note_data.notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + await new_note.add_to_notebook(note_data.notebook_id) + + return NoteResponse( + id=new_note.id, + title=new_note.title, + content=new_note.content, + note_type=new_note.note_type, + created=str(new_note.created), + updated=str(new_note.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error creating note: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error creating note: {str(e)}") + + +@router.get("/notes/{note_id}", response_model=NoteResponse) +async def get_note(note_id: str): + """Get a specific note by ID.""" + try: + note = await Note.get(note_id) + if not note: + raise HTTPException(status_code=404, detail="Note not found") + + return NoteResponse( + id=note.id, + title=note.title, + content=note.content, + note_type=note.note_type, + created=str(note.created), + updated=str(note.updated), + ) + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching note {note_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching note: {str(e)}") + + +@router.put("/notes/{note_id}", response_model=NoteResponse) +async def update_note(note_id: str, note_update: NoteUpdate): + """Update a note.""" + try: + note = await Note.get(note_id) + if not note: + raise HTTPException(status_code=404, detail="Note not found") + + # Update only provided fields + if note_update.title is not None: + note.title = note_update.title + if note_update.content is not None: + note.content = note_update.content + if note_update.note_type is not None: + note.note_type = note_update.note_type + + await note.save() + + return NoteResponse( + id=note.id, + title=note.title, + content=note.content, + note_type=note.note_type, + created=str(note.created), + updated=str(note.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error updating note {note_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error updating note: {str(e)}") + + +@router.delete("/notes/{note_id}") +async def delete_note(note_id: str): + """Delete a note.""" + try: + note = await Note.get(note_id) + if not note: + raise HTTPException(status_code=404, detail="Note not found") + + await note.delete() + + return {"message": "Note deleted successfully"} + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting note {note_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error deleting note: {str(e)}") \ No newline at end of file diff --git a/api/routers/podcasts.py b/api/routers/podcasts.py new file mode 100644 index 0000000..2f77611 --- /dev/null +++ b/api/routers/podcasts.py @@ -0,0 +1,183 @@ +from typing import List, Optional +from pathlib import Path + +from fastapi import APIRouter, HTTPException +from loguru import logger +from pydantic import BaseModel + +from api.podcast_service import ( + PodcastGenerationRequest, + PodcastGenerationResponse, + PodcastService, +) +from open_notebook.domain.podcast import PodcastEpisode + +router = APIRouter() + + +class PodcastEpisodeResponse(BaseModel): + id: str + name: str + episode_profile: dict + speaker_profile: dict + briefing: str + audio_file: Optional[str] = None + transcript: Optional[dict] = None + outline: Optional[dict] = None + created: Optional[str] = None + job_status: Optional[str] = None + + +@router.post("/podcasts/generate", response_model=PodcastGenerationResponse) +async def generate_podcast(request: PodcastGenerationRequest): + """ + Generate a podcast episode using Episode Profiles. + Returns immediately with job ID for status tracking. + """ + try: + job_id = await PodcastService.submit_generation_job( + episode_profile_name=request.episode_profile, + speaker_profile_name=request.speaker_profile, + episode_name=request.episode_name, + notebook_id=request.notebook_id, + content=request.content, + briefing_suffix=request.briefing_suffix, + ) + + return PodcastGenerationResponse( + job_id=job_id, + status="submitted", + message=f"Podcast generation started for episode '{request.episode_name}'", + episode_profile=request.episode_profile, + episode_name=request.episode_name, + ) + + except Exception as e: + logger.error(f"Error generating podcast: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Failed to generate podcast: {str(e)}" + ) + + +@router.get("/podcasts/jobs/{job_id}") +async def get_podcast_job_status(job_id: str): + """Get the status of a podcast generation job""" + try: + status_data = await PodcastService.get_job_status(job_id) + return status_data + + except Exception as e: + logger.error(f"Error fetching podcast job status: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Failed to fetch job status: {str(e)}" + ) + + +@router.get("/podcasts/episodes", response_model=List[PodcastEpisodeResponse]) +async def list_podcast_episodes(): + """List all podcast episodes""" + try: + episodes = await PodcastService.list_episodes() + + response_episodes = [] + for episode in episodes: + # Skip incomplete episodes without command or audio + if not episode.command and not episode.audio_file: + continue + + # Get job status if available + job_status = None + if episode.command: + try: + job_status = await episode.get_job_status() + except: + job_status = "unknown" + else: + # No command but has audio file = completed import + job_status = "completed" + + response_episodes.append( + PodcastEpisodeResponse( + id=str(episode.id), + name=episode.name, + episode_profile=episode.episode_profile, + speaker_profile=episode.speaker_profile, + briefing=episode.briefing, + audio_file=episode.audio_file, + transcript=episode.transcript, + outline=episode.outline, + created=str(episode.created) if episode.created else None, + job_status=job_status, + ) + ) + + return response_episodes + + except Exception as e: + logger.error(f"Error listing podcast episodes: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Failed to list podcast episodes: {str(e)}" + ) + + +@router.get("/podcasts/episodes/{episode_id}", response_model=PodcastEpisodeResponse) +async def get_podcast_episode(episode_id: str): + """Get a specific podcast episode""" + try: + episode = await PodcastService.get_episode(episode_id) + + # Get job status if available + job_status = None + if episode.command: + try: + job_status = await episode.get_job_status() + except: + job_status = "unknown" + else: + # No command but has audio file = completed import + job_status = "completed" if episode.audio_file else "unknown" + + return PodcastEpisodeResponse( + id=str(episode.id), + name=episode.name, + episode_profile=episode.episode_profile, + speaker_profile=episode.speaker_profile, + briefing=episode.briefing, + audio_file=episode.audio_file, + transcript=episode.transcript, + outline=episode.outline, + created=str(episode.created) if episode.created else None, + job_status=job_status, + ) + + except Exception as e: + logger.error(f"Error fetching podcast episode: {str(e)}") + raise HTTPException(status_code=404, detail=f"Episode not found: {str(e)}") + + +@router.delete("/podcasts/episodes/{episode_id}") +async def delete_podcast_episode(episode_id: str): + """Delete a podcast episode and its associated audio file""" + try: + # Get the episode first to check if it exists and get the audio file path + episode = await PodcastService.get_episode(episode_id) + + # Delete the physical audio file if it exists + if episode.audio_file: + audio_path = Path(episode.audio_file) + if audio_path.exists(): + try: + audio_path.unlink() + logger.info(f"Deleted audio file: {audio_path}") + except Exception as e: + logger.warning(f"Failed to delete audio file {audio_path}: {e}") + + # Delete the episode from the database + await episode.delete() + + logger.info(f"Deleted podcast episode: {episode_id}") + return {"message": "Episode deleted successfully", "episode_id": episode_id} + + except Exception as e: + logger.error(f"Error deleting podcast episode: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to delete episode: {str(e)}") diff --git a/api/routers/search.py b/api/routers/search.py new file mode 100644 index 0000000..fd14362 --- /dev/null +++ b/api/routers/search.py @@ -0,0 +1,213 @@ +import asyncio +from typing import AsyncGenerator, Dict + +from fastapi import APIRouter, HTTPException +from fastapi.responses import StreamingResponse +from loguru import logger + +from api.models import AskRequest, AskResponse, SearchRequest, SearchResponse +from open_notebook.domain.models import Model, model_manager +from open_notebook.domain.notebook import text_search, vector_search +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError +from open_notebook.graphs.ask import graph as ask_graph + +router = APIRouter() + + +@router.post("/search", response_model=SearchResponse) +async def search_knowledge_base(search_request: SearchRequest): + """Search the knowledge base using text or vector search.""" + try: + if search_request.type == "vector": + # Check if embedding model is available for vector search + if not await model_manager.get_embedding_model(): + raise HTTPException( + status_code=400, + detail="Vector search requires an embedding model. Please configure one in the Models section.", + ) + + results = await vector_search( + keyword=search_request.query, + results=search_request.limit, + source=search_request.search_sources, + note=search_request.search_notes, + minimum_score=search_request.minimum_score, + ) + else: + # Text search + results = await text_search( + keyword=search_request.query, + results=search_request.limit, + source=search_request.search_sources, + note=search_request.search_notes, + ) + + return SearchResponse( + results=results or [], + total_count=len(results) if results else 0, + search_type=search_request.type, + ) + + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except DatabaseOperationError as e: + logger.error(f"Database error during search: {str(e)}") + raise HTTPException(status_code=500, detail=f"Search failed: {str(e)}") + except Exception as e: + logger.error(f"Unexpected error during search: {str(e)}") + raise HTTPException(status_code=500, detail=f"Search failed: {str(e)}") + + +async def stream_ask_response( + question: str, strategy_model: Model, answer_model: Model, final_answer_model: Model +) -> AsyncGenerator[str, None]: + """Stream the ask response as Server-Sent Events.""" + try: + final_answer = None + + async for chunk in ask_graph.astream( + input=dict(question=question), + config=dict( + configurable=dict( + strategy_model=strategy_model.id, + answer_model=answer_model.id, + final_answer_model=final_answer_model.id, + ) + ), + stream_mode="updates", + ): + if "agent" in chunk: + strategy_data = { + "type": "strategy", + "reasoning": chunk["agent"]["strategy"].reasoning, + "searches": [ + {"term": search.term, "instructions": search.instructions} + for search in chunk["agent"]["strategy"].searches + ], + } + yield f"data: {strategy_data}\n\n" + + elif "provide_answer" in chunk: + for answer in chunk["provide_answer"]["answers"]: + answer_data = {"type": "answer", "content": answer} + yield f"data: {answer_data}\n\n" + + elif "write_final_answer" in chunk: + final_answer = chunk["write_final_answer"]["final_answer"] + final_data = {"type": "final_answer", "content": final_answer} + yield f"data: {final_data}\n\n" + + # Send completion signal + yield f"data: {{'type': 'complete', 'final_answer': '{final_answer}'}}\n\n" + + except Exception as e: + logger.error(f"Error in ask streaming: {str(e)}") + error_data = {"type": "error", "message": str(e)} + yield f"data: {error_data}\n\n" + + +@router.post("/search/ask") +async def ask_knowledge_base(ask_request: AskRequest): + """Ask the knowledge base a question using AI models.""" + try: + # Validate models exist + strategy_model = await Model.get(ask_request.strategy_model) + answer_model = await Model.get(ask_request.answer_model) + final_answer_model = await Model.get(ask_request.final_answer_model) + + if not strategy_model: + raise HTTPException( + status_code=400, + detail=f"Strategy model {ask_request.strategy_model} not found", + ) + if not answer_model: + raise HTTPException( + status_code=400, + detail=f"Answer model {ask_request.answer_model} not found", + ) + if not final_answer_model: + raise HTTPException( + status_code=400, + detail=f"Final answer model {ask_request.final_answer_model} not found", + ) + + # Check if embedding model is available + if not await model_manager.get_embedding_model(): + raise HTTPException( + status_code=400, + detail="Ask feature requires an embedding model. Please configure one in the Models section.", + ) + + # For streaming response + return StreamingResponse( + await stream_ask_response( + ask_request.question, strategy_model, answer_model, final_answer_model + ), + media_type="text/plain", + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error in ask endpoint: {str(e)}") + raise HTTPException(status_code=500, detail=f"Ask operation failed: {str(e)}") + + +@router.post("/search/ask/simple", response_model=AskResponse) +async def ask_knowledge_base_simple(ask_request: AskRequest): + """Ask the knowledge base a question and return a simple response (non-streaming).""" + try: + # Validate models exist + strategy_model = await Model.get(ask_request.strategy_model) + answer_model = await Model.get(ask_request.answer_model) + final_answer_model = await Model.get(ask_request.final_answer_model) + + if not strategy_model: + raise HTTPException( + status_code=400, + detail=f"Strategy model {ask_request.strategy_model} not found", + ) + if not answer_model: + raise HTTPException( + status_code=400, + detail=f"Answer model {ask_request.answer_model} not found", + ) + if not final_answer_model: + raise HTTPException( + status_code=400, + detail=f"Final answer model {ask_request.final_answer_model} not found", + ) + + # Check if embedding model is available + if not await model_manager.get_embedding_model(): + raise HTTPException( + status_code=400, + detail="Ask feature requires an embedding model. Please configure one in the Models section.", + ) + + # Run the ask graph and get final result + final_answer = None + async for chunk in ask_graph.astream( + input=dict(question=ask_request.question), + config=dict( + configurable=dict( + strategy_model=strategy_model.id, + answer_model=answer_model.id, + final_answer_model=final_answer_model.id, + ) + ), + stream_mode="updates", + ): + if "write_final_answer" in chunk: + final_answer = chunk["write_final_answer"]["final_answer"] + + if not final_answer: + raise HTTPException(status_code=500, detail="No answer generated") + + return AskResponse(answer=final_answer, question=ask_request.question) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error in ask simple endpoint: {str(e)}") + raise HTTPException(status_code=500, detail=f"Ask operation failed: {str(e)}") diff --git a/api/routers/settings.py b/api/routers/settings.py new file mode 100644 index 0000000..d44562b --- /dev/null +++ b/api/routers/settings.py @@ -0,0 +1,62 @@ +from fastapi import APIRouter, HTTPException +from loguru import logger + +from api.models import SettingsResponse, SettingsUpdate +from open_notebook.domain.content_settings import ContentSettings +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError + +router = APIRouter() + + +@router.get("/settings", response_model=SettingsResponse) +async def get_settings(): + """Get all application settings.""" + try: + settings = await ContentSettings.get_instance() + + return SettingsResponse( + default_content_processing_engine_doc=settings.default_content_processing_engine_doc, + default_content_processing_engine_url=settings.default_content_processing_engine_url, + default_embedding_option=settings.default_embedding_option, + auto_delete_files=settings.auto_delete_files, + youtube_preferred_languages=settings.youtube_preferred_languages, + ) + except Exception as e: + logger.error(f"Error fetching settings: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching settings: {str(e)}") + + +@router.put("/settings", response_model=SettingsResponse) +async def update_settings(settings_update: SettingsUpdate): + """Update application settings.""" + try: + settings = await ContentSettings.get_instance() + + # Update only provided fields + if settings_update.default_content_processing_engine_doc is not None: + settings.default_content_processing_engine_doc = settings_update.default_content_processing_engine_doc + if settings_update.default_content_processing_engine_url is not None: + settings.default_content_processing_engine_url = settings_update.default_content_processing_engine_url + if settings_update.default_embedding_option is not None: + settings.default_embedding_option = settings_update.default_embedding_option + if settings_update.auto_delete_files is not None: + settings.auto_delete_files = settings_update.auto_delete_files + if settings_update.youtube_preferred_languages is not None: + settings.youtube_preferred_languages = settings_update.youtube_preferred_languages + + await settings.update() + + return SettingsResponse( + default_content_processing_engine_doc=settings.default_content_processing_engine_doc, + default_content_processing_engine_url=settings.default_content_processing_engine_url, + default_embedding_option=settings.default_embedding_option, + auto_delete_files=settings.auto_delete_files, + youtube_preferred_languages=settings.youtube_preferred_languages, + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error updating settings: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error updating settings: {str(e)}") \ No newline at end of file diff --git a/api/routers/sources.py b/api/routers/sources.py new file mode 100644 index 0000000..eda8df4 --- /dev/null +++ b/api/routers/sources.py @@ -0,0 +1,310 @@ +from typing import List, Optional + +from fastapi import APIRouter, HTTPException, Query +from loguru import logger + +from api.models import ( + AssetModel, + CreateSourceInsightRequest, + SourceCreate, + SourceInsightResponse, + SourceListResponse, + SourceResponse, + SourceUpdate, +) +from open_notebook.domain.notebook import Notebook, Source +from open_notebook.domain.transformation import Transformation +from open_notebook.exceptions import InvalidInputError +from open_notebook.graphs.source import source_graph + +router = APIRouter() + + +@router.get("/sources", response_model=List[SourceListResponse]) +async def get_sources( + notebook_id: Optional[str] = Query(None, description="Filter by notebook ID"), +): + """Get all sources with optional notebook filtering.""" + try: + if notebook_id: + # Get sources for a specific notebook + notebook = await Notebook.get(notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + sources = await notebook.get_sources() + else: + # Get all sources + sources = await Source.get_all(order_by="updated desc") + + # Create response list with async insights count + response_list = [] + for source in sources: + insights = await source.get_insights() + response_list.append( + SourceListResponse( + id=source.id, + title=source.title, + topics=source.topics or [], + asset=AssetModel( + file_path=source.asset.file_path if source.asset else None, + url=source.asset.url if source.asset else None, + ) + if source.asset + else None, + embedded_chunks=await source.get_embedded_chunks(), + insights_count=len(insights), + created=str(source.created), + updated=str(source.updated), + ) + ) + + return response_list + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching sources: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching sources: {str(e)}") + + +@router.post("/sources", response_model=SourceResponse) +async def create_source(source_data: SourceCreate): + """Create a new source.""" + try: + # Verify notebook exists + notebook = await Notebook.get(source_data.notebook_id) + if not notebook: + raise HTTPException(status_code=404, detail="Notebook not found") + + # Prepare content_state for source_graph + content_state = {} + + if source_data.type == "link": + if not source_data.url: + raise HTTPException( + status_code=400, detail="URL is required for link type" + ) + content_state["url"] = source_data.url + elif source_data.type == "upload": + if not source_data.file_path: + raise HTTPException( + status_code=400, detail="File path is required for upload type" + ) + content_state["file_path"] = source_data.file_path + content_state["delete_source"] = source_data.delete_source + elif source_data.type == "text": + if not source_data.content: + raise HTTPException( + status_code=400, detail="Content is required for text type" + ) + content_state["content"] = source_data.content + else: + raise HTTPException( + status_code=400, + detail="Invalid source type. Must be link, upload, or text", + ) + + # Get transformations to apply + transformations = [] + if source_data.transformations: + for trans_id in source_data.transformations: + transformation = await Transformation.get(trans_id) + if not transformation: + raise HTTPException( + status_code=404, detail=f"Transformation {trans_id} not found" + ) + transformations.append(transformation) + + # Process source using the source_graph + result = await source_graph.ainvoke( + { + "content_state": content_state, + "notebook_id": source_data.notebook_id, + "apply_transformations": transformations, + "embed": source_data.embed, + } + ) + + source = result["source"] + + return SourceResponse( + id=source.id, + title=source.title, + topics=source.topics or [], + asset=AssetModel( + file_path=source.asset.file_path if source.asset else None, + url=source.asset.url if source.asset else None, + ) + if source.asset + else None, + full_text=source.full_text, + embedded_chunks=await source.get_embedded_chunks(), + created=str(source.created), + updated=str(source.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error creating source: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error creating source: {str(e)}") + + +@router.get("/sources/{source_id}", response_model=SourceResponse) +async def get_source(source_id: str): + """Get a specific source by ID.""" + try: + source = await Source.get(source_id) + if not source: + raise HTTPException(status_code=404, detail="Source not found") + + return SourceResponse( + id=source.id, + title=source.title, + topics=source.topics or [], + asset=AssetModel( + file_path=source.asset.file_path if source.asset else None, + url=source.asset.url if source.asset else None, + ) + if source.asset + else None, + full_text=source.full_text, + embedded_chunks=await source.get_embedded_chunks(), + created=str(source.created), + updated=str(source.updated), + ) + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching source {source_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching source: {str(e)}") + + +@router.put("/sources/{source_id}", response_model=SourceResponse) +async def update_source(source_id: str, source_update: SourceUpdate): + """Update a source.""" + try: + source = await Source.get(source_id) + if not source: + raise HTTPException(status_code=404, detail="Source not found") + + # Update only provided fields + if source_update.title is not None: + source.title = source_update.title + if source_update.topics is not None: + source.topics = source_update.topics + + await source.save() + + return SourceResponse( + id=source.id, + title=source.title, + topics=source.topics or [], + asset=AssetModel( + file_path=source.asset.file_path if source.asset else None, + url=source.asset.url if source.asset else None, + ) + if source.asset + else None, + full_text=source.full_text, + embedded_chunks=await source.get_embedded_chunks(), + created=str(source.created), + updated=str(source.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error updating source {source_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error updating source: {str(e)}") + + +@router.delete("/sources/{source_id}") +async def delete_source(source_id: str): + """Delete a source.""" + try: + source = await Source.get(source_id) + if not source: + raise HTTPException(status_code=404, detail="Source not found") + + await source.delete() + + return {"message": "Source deleted successfully"} + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting source {source_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error deleting source: {str(e)}") + + +@router.get("/sources/{source_id}/insights", response_model=List[SourceInsightResponse]) +async def get_source_insights(source_id: str): + """Get all insights for a specific source.""" + try: + source = await Source.get(source_id) + if not source: + raise HTTPException(status_code=404, detail="Source not found") + + insights = await source.get_insights() + return [ + SourceInsightResponse( + id=insight.id, + source_id=source_id, + insight_type=insight.insight_type, + content=insight.content, + created=str(insight.created), + updated=str(insight.updated) + ) + for insight in insights + ] + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching insights for source {source_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching insights: {str(e)}") + + +@router.post("/sources/{source_id}/insights", response_model=SourceInsightResponse) +async def create_source_insight( + source_id: str, + request: CreateSourceInsightRequest +): + """Create a new insight for a source by running a transformation.""" + try: + # Get source + source = await Source.get(source_id) + if not source: + raise HTTPException(status_code=404, detail="Source not found") + + # Get transformation + transformation = await Transformation.get(request.transformation_id) + if not transformation: + raise HTTPException(status_code=404, detail="Transformation not found") + + # Run transformation graph + from open_notebook.graphs.transformation import graph as transform_graph + await transform_graph.ainvoke( + input=dict(source=source, transformation=transformation) + ) + + # Get the newly created insight (last one) + insights = await source.get_insights() + if insights: + newest = insights[-1] + return SourceInsightResponse( + id=newest.id, + source_id=source_id, + insight_type=newest.insight_type, + content=newest.content, + created=str(newest.created), + updated=str(newest.updated) + ) + else: + raise HTTPException(status_code=500, detail="Failed to create insight") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error creating insight for source {source_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error creating insight: {str(e)}") diff --git a/api/routers/speaker_profiles.py b/api/routers/speaker_profiles.py new file mode 100644 index 0000000..68700b8 --- /dev/null +++ b/api/routers/speaker_profiles.py @@ -0,0 +1,222 @@ +from typing import List, Dict, Any +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel, Field +from loguru import logger + +from open_notebook.domain.podcast import SpeakerProfile + + +router = APIRouter() + + +class SpeakerProfileResponse(BaseModel): + id: str + name: str + description: str + tts_provider: str + tts_model: str + speakers: List[Dict[str, Any]] + + +@router.get("/speaker-profiles", response_model=List[SpeakerProfileResponse]) +async def list_speaker_profiles(): + """List all available speaker profiles""" + try: + profiles = await SpeakerProfile.get_all(order_by="name asc") + + return [ + SpeakerProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + tts_provider=profile.tts_provider, + tts_model=profile.tts_model, + speakers=profile.speakers + ) + for profile in profiles + ] + + except Exception as e: + logger.error(f"Failed to fetch speaker profiles: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to fetch speaker profiles: {str(e)}" + ) + + +@router.get("/speaker-profiles/{profile_name}", response_model=SpeakerProfileResponse) +async def get_speaker_profile(profile_name: str): + """Get a specific speaker profile by name""" + try: + profile = await SpeakerProfile.get_by_name(profile_name) + + if not profile: + raise HTTPException( + status_code=404, + detail=f"Speaker profile '{profile_name}' not found" + ) + + return SpeakerProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + tts_provider=profile.tts_provider, + tts_model=profile.tts_model, + speakers=profile.speakers + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to fetch speaker profile '{profile_name}': {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to fetch speaker profile: {str(e)}" + ) + + +class SpeakerProfileCreate(BaseModel): + name: str = Field(..., description="Unique profile name") + description: str = Field("", description="Profile description") + tts_provider: str = Field(..., description="TTS provider") + tts_model: str = Field(..., description="TTS model name") + speakers: List[Dict[str, Any]] = Field(..., description="Array of speaker configurations") + + +@router.post("/speaker-profiles", response_model=SpeakerProfileResponse) +async def create_speaker_profile(profile_data: SpeakerProfileCreate): + """Create a new speaker profile""" + try: + profile = SpeakerProfile( + name=profile_data.name, + description=profile_data.description, + tts_provider=profile_data.tts_provider, + tts_model=profile_data.tts_model, + speakers=profile_data.speakers + ) + + await profile.save() + + return SpeakerProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + tts_provider=profile.tts_provider, + tts_model=profile.tts_model, + speakers=profile.speakers + ) + + except Exception as e: + logger.error(f"Failed to create speaker profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to create speaker profile: {str(e)}" + ) + + +@router.put("/speaker-profiles/{profile_id}", response_model=SpeakerProfileResponse) +async def update_speaker_profile(profile_id: str, profile_data: SpeakerProfileCreate): + """Update an existing speaker profile""" + try: + profile = await SpeakerProfile.get(profile_id) + + if not profile: + raise HTTPException( + status_code=404, + detail=f"Speaker profile '{profile_id}' not found" + ) + + # Update fields + profile.name = profile_data.name + profile.description = profile_data.description + profile.tts_provider = profile_data.tts_provider + profile.tts_model = profile_data.tts_model + profile.speakers = profile_data.speakers + + await profile.save() + + return SpeakerProfileResponse( + id=str(profile.id), + name=profile.name, + description=profile.description or "", + tts_provider=profile.tts_provider, + tts_model=profile.tts_model, + speakers=profile.speakers + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to update speaker profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to update speaker profile: {str(e)}" + ) + + +@router.delete("/speaker-profiles/{profile_id}") +async def delete_speaker_profile(profile_id: str): + """Delete a speaker profile""" + try: + profile = await SpeakerProfile.get(profile_id) + + if not profile: + raise HTTPException( + status_code=404, + detail=f"Speaker profile '{profile_id}' not found" + ) + + await profile.delete() + + return {"message": "Speaker profile deleted successfully"} + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to delete speaker profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to delete speaker profile: {str(e)}" + ) + + +@router.post("/speaker-profiles/{profile_id}/duplicate", response_model=SpeakerProfileResponse) +async def duplicate_speaker_profile(profile_id: str): + """Duplicate a speaker profile""" + try: + original = await SpeakerProfile.get(profile_id) + + if not original: + raise HTTPException( + status_code=404, + detail=f"Speaker profile '{profile_id}' not found" + ) + + # Create duplicate with modified name + duplicate = SpeakerProfile( + name=f"{original.name} - Copy", + description=original.description, + tts_provider=original.tts_provider, + tts_model=original.tts_model, + speakers=original.speakers + ) + + await duplicate.save() + + return SpeakerProfileResponse( + id=str(duplicate.id), + name=duplicate.name, + description=duplicate.description or "", + tts_provider=duplicate.tts_provider, + tts_model=duplicate.tts_model, + speakers=duplicate.speakers + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Failed to duplicate speaker profile: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to duplicate speaker profile: {str(e)}" + ) \ No newline at end of file diff --git a/api/routers/transformations.py b/api/routers/transformations.py new file mode 100644 index 0000000..60465bd --- /dev/null +++ b/api/routers/transformations.py @@ -0,0 +1,210 @@ +from typing import List + +from fastapi import APIRouter, HTTPException +from loguru import logger + +from api.models import ( + TransformationCreate, + TransformationExecuteRequest, + TransformationExecuteResponse, + TransformationResponse, + TransformationUpdate, +) +from open_notebook.domain.models import Model +from open_notebook.domain.transformation import Transformation +from open_notebook.exceptions import DatabaseOperationError, InvalidInputError +from open_notebook.graphs.transformation import graph as transformation_graph + +router = APIRouter() + + +@router.get("/transformations", response_model=List[TransformationResponse]) +async def get_transformations(): + """Get all transformations.""" + try: + transformations = await Transformation.get_all(order_by="name asc") + + return [ + TransformationResponse( + id=transformation.id, + name=transformation.name, + title=transformation.title, + description=transformation.description, + prompt=transformation.prompt, + apply_default=transformation.apply_default, + created=str(transformation.created), + updated=str(transformation.updated), + ) + for transformation in transformations + ] + except Exception as e: + logger.error(f"Error fetching transformations: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Error fetching transformations: {str(e)}" + ) + + +@router.post("/transformations", response_model=TransformationResponse) +async def create_transformation(transformation_data: TransformationCreate): + """Create a new transformation.""" + try: + new_transformation = Transformation( + name=transformation_data.name, + title=transformation_data.title, + description=transformation_data.description, + prompt=transformation_data.prompt, + apply_default=transformation_data.apply_default, + ) + await new_transformation.save() + + return TransformationResponse( + id=new_transformation.id, + name=new_transformation.name, + title=new_transformation.title, + description=new_transformation.description, + prompt=new_transformation.prompt, + apply_default=new_transformation.apply_default, + created=str(new_transformation.created), + updated=str(new_transformation.updated), + ) + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error creating transformation: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Error creating transformation: {str(e)}" + ) + + +@router.get( + "/transformations/{transformation_id}", response_model=TransformationResponse +) +async def get_transformation(transformation_id: str): + """Get a specific transformation by ID.""" + try: + transformation = await Transformation.get(transformation_id) + if not transformation: + raise HTTPException(status_code=404, detail="Transformation not found") + + return TransformationResponse( + id=transformation.id, + name=transformation.name, + title=transformation.title, + description=transformation.description, + prompt=transformation.prompt, + apply_default=transformation.apply_default, + created=str(transformation.created), + updated=str(transformation.updated), + ) + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching transformation {transformation_id}: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Error fetching transformation: {str(e)}" + ) + + +@router.put( + "/transformations/{transformation_id}", response_model=TransformationResponse +) +async def update_transformation( + transformation_id: str, transformation_update: TransformationUpdate +): + """Update a transformation.""" + try: + transformation = await Transformation.get(transformation_id) + if not transformation: + raise HTTPException(status_code=404, detail="Transformation not found") + + # Update only provided fields + if transformation_update.name is not None: + transformation.name = transformation_update.name + if transformation_update.title is not None: + transformation.title = transformation_update.title + if transformation_update.description is not None: + transformation.description = transformation_update.description + if transformation_update.prompt is not None: + transformation.prompt = transformation_update.prompt + if transformation_update.apply_default is not None: + transformation.apply_default = transformation_update.apply_default + + await transformation.save() + + return TransformationResponse( + id=transformation.id, + name=transformation.name, + title=transformation.title, + description=transformation.description, + prompt=transformation.prompt, + apply_default=transformation.apply_default, + created=str(transformation.created), + updated=str(transformation.updated), + ) + except HTTPException: + raise + except InvalidInputError as e: + raise HTTPException(status_code=400, detail=str(e)) + except Exception as e: + logger.error(f"Error updating transformation {transformation_id}: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Error updating transformation: {str(e)}" + ) + + +@router.delete("/transformations/{transformation_id}") +async def delete_transformation(transformation_id: str): + """Delete a transformation.""" + try: + transformation = await Transformation.get(transformation_id) + if not transformation: + raise HTTPException(status_code=404, detail="Transformation not found") + + await transformation.delete() + + return {"message": "Transformation deleted successfully"} + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting transformation {transformation_id}: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Error deleting transformation: {str(e)}" + ) + + +@router.post("/transformations/execute", response_model=TransformationExecuteResponse) +async def execute_transformation(execute_request: TransformationExecuteRequest): + """Execute a transformation on input text.""" + try: + # Validate transformation exists + transformation = await Transformation.get(execute_request.transformation_id) + if not transformation: + raise HTTPException(status_code=404, detail="Transformation not found") + + # Validate model exists + model = await Model.get(execute_request.model_id) + if not model: + raise HTTPException(status_code=404, detail="Model not found") + + # Execute the transformation + result = await transformation_graph.ainvoke( + dict( + input_text=execute_request.input_text, + transformation=transformation, + ), + config=dict(configurable={"model_id": execute_request.model_id}), + ) + + return TransformationExecuteResponse( + output=result["output"], + transformation_id=execute_request.transformation_id, + model_id=execute_request.model_id, + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error executing transformation: {str(e)}") + raise HTTPException( + status_code=500, detail=f"Error executing transformation: {str(e)}" + ) diff --git a/api/search_service.py b/api/search_service.py new file mode 100644 index 0000000..22f823d --- /dev/null +++ b/api/search_service.py @@ -0,0 +1,56 @@ +""" +Search service layer using API. +""" + +from typing import Dict, List, Any + +from loguru import logger + +from api.client import api_client + + +class SearchService: + """Service layer for search operations using API.""" + + def __init__(self): + logger.info("Using API for search operations") + + def search( + self, + query: str, + search_type: str = "text", + limit: int = 100, + search_sources: bool = True, + search_notes: bool = True, + minimum_score: float = 0.2 + ) -> List[Dict[str, Any]]: + """Search the knowledge base.""" + response = api_client.search( + query=query, + search_type=search_type, + limit=limit, + search_sources=search_sources, + search_notes=search_notes, + minimum_score=minimum_score + ) + return response.get("results", []) + + def ask_knowledge_base( + self, + question: str, + strategy_model: str, + answer_model: str, + final_answer_model: str + ) -> Dict[str, str]: + """Ask the knowledge base a question.""" + response = api_client.ask_simple( + question=question, + strategy_model=strategy_model, + answer_model=answer_model, + final_answer_model=final_answer_model + ) + return response + + +# Global service instance +search_service = SearchService() \ No newline at end of file diff --git a/api/settings_service.py b/api/settings_service.py new file mode 100644 index 0000000..e9d1504 --- /dev/null +++ b/api/settings_service.py @@ -0,0 +1,57 @@ +""" +Settings service layer using API. +""" + +from typing import Dict + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.content_settings import ContentSettings + + +class SettingsService: + """Service layer for settings operations using API.""" + + def __init__(self): + logger.info("Using API for settings operations") + + def get_settings(self) -> ContentSettings: + """Get application settings.""" + settings_data = api_client.get_settings() + + # Create ContentSettings object from API response + settings = ContentSettings( + default_content_processing_engine_doc=settings_data.get("default_content_processing_engine_doc"), + default_content_processing_engine_url=settings_data.get("default_content_processing_engine_url"), + default_embedding_option=settings_data.get("default_embedding_option"), + auto_delete_files=settings_data.get("auto_delete_files"), + youtube_preferred_languages=settings_data.get("youtube_preferred_languages"), + ) + + return settings + + def update_settings(self, settings: ContentSettings) -> ContentSettings: + """Update application settings.""" + updates = { + "default_content_processing_engine_doc": settings.default_content_processing_engine_doc, + "default_content_processing_engine_url": settings.default_content_processing_engine_url, + "default_embedding_option": settings.default_embedding_option, + "auto_delete_files": settings.auto_delete_files, + "youtube_preferred_languages": settings.youtube_preferred_languages, + } + + settings_data = api_client.update_settings(**updates) + + # Update the settings object with the response + settings.default_content_processing_engine_doc = settings_data.get("default_content_processing_engine_doc") + settings.default_content_processing_engine_url = settings_data.get("default_content_processing_engine_url") + settings.default_embedding_option = settings_data.get("default_embedding_option") + settings.auto_delete_files = settings_data.get("auto_delete_files") + settings.youtube_preferred_languages = settings_data.get("youtube_preferred_languages") + + return settings + + +# Global service instance +settings_service = SettingsService() \ No newline at end of file diff --git a/api/sources_service.py b/api/sources_service.py new file mode 100644 index 0000000..03a123b --- /dev/null +++ b/api/sources_service.py @@ -0,0 +1,183 @@ +""" +Sources service layer using API. +""" + +from dataclasses import dataclass +from typing import List, Optional + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.notebook import Asset, Source + + +@dataclass +class SourceWithMetadata: + """Source object with additional metadata from API.""" + source: Source + embedded_chunks: int + + # Expose common source properties for easy access + @property + def id(self): + return self.source.id + + @property + def title(self): + return self.source.title + + @title.setter + def title(self, value): + self.source.title = value + + @property + def topics(self): + return self.source.topics + + @property + def asset(self): + return self.source.asset + + @property + def full_text(self): + return self.source.full_text + + @property + def created(self): + return self.source.created + + @property + def updated(self): + return self.source.updated + + +class SourcesService: + """Service layer for sources operations using API.""" + + def __init__(self): + logger.info("Using API for sources operations") + + def get_all_sources(self, notebook_id: Optional[str] = None) -> List[SourceWithMetadata]: + """Get all sources with optional notebook filtering.""" + sources_data = api_client.get_sources(notebook_id=notebook_id) + # Convert API response to SourceWithMetadata objects + sources = [] + for source_data in sources_data: + source = Source( + title=source_data["title"], + topics=source_data["topics"], + asset=Asset( + file_path=source_data["asset"]["file_path"] + if source_data["asset"] + else None, + url=source_data["asset"]["url"] if source_data["asset"] else None, + ) + if source_data["asset"] + else None, + ) + source.id = source_data["id"] + source.created = source_data["created"] + source.updated = source_data["updated"] + + # Wrap in SourceWithMetadata + source_with_metadata = SourceWithMetadata( + source=source, + embedded_chunks=source_data.get("embedded_chunks", 0) + ) + sources.append(source_with_metadata) + return sources + + def get_source(self, source_id: str) -> SourceWithMetadata: + """Get a specific source.""" + source_data = api_client.get_source(source_id) + source = Source( + title=source_data["title"], + topics=source_data["topics"], + full_text=source_data["full_text"], + asset=Asset( + file_path=source_data["asset"]["file_path"] + if source_data["asset"] + else None, + url=source_data["asset"]["url"] if source_data["asset"] else None, + ) + if source_data["asset"] + else None, + ) + source.id = source_data["id"] + source.created = source_data["created"] + source.updated = source_data["updated"] + + return SourceWithMetadata( + source=source, + embedded_chunks=source_data.get("embedded_chunks", 0) + ) + + def create_source( + self, + notebook_id: str, + source_type: str, + url: Optional[str] = None, + file_path: Optional[str] = None, + content: Optional[str] = None, + title: Optional[str] = None, + transformations: Optional[List[str]] = None, + embed: bool = False, + delete_source: bool = False, + ) -> Source: + """Create a new source.""" + source_data = api_client.create_source( + notebook_id=notebook_id, + source_type=source_type, + url=url, + file_path=file_path, + content=content, + title=title, + transformations=transformations, + embed=embed, + delete_source=delete_source, + ) + + source = Source( + title=source_data["title"], + topics=source_data["topics"], + full_text=source_data["full_text"], + asset=Asset( + file_path=source_data["asset"]["file_path"] + if source_data["asset"] + else None, + url=source_data["asset"]["url"] if source_data["asset"] else None, + ) + if source_data["asset"] + else None, + ) + source.id = source_data["id"] + source.created = source_data["created"] + source.updated = source_data["updated"] + return source + + def update_source(self, source: Source) -> Source: + """Update a source.""" + if not source.id: + raise ValueError("Source ID is required for update") + + updates = { + "title": source.title, + "topics": source.topics, + } + source_data = api_client.update_source(source.id, **updates) + + # Update the source object with the response + source.title = source_data["title"] + source.topics = source_data["topics"] + source.updated = source_data["updated"] + + return source + + def delete_source(self, source_id: str) -> bool: + """Delete a source.""" + api_client.delete_source(source_id) + return True + + +# Global service instance +sources_service = SourcesService() diff --git a/api/transformations_service.py b/api/transformations_service.py new file mode 100644 index 0000000..6821bf3 --- /dev/null +++ b/api/transformations_service.py @@ -0,0 +1,124 @@ +""" +Transformations service layer using API. +""" + +from datetime import datetime +from typing import Dict, List + +from loguru import logger + +from api.client import api_client +from open_notebook.domain.transformation import Transformation + + +class TransformationsService: + """Service layer for transformations operations using API.""" + + def __init__(self): + logger.info("Using API for transformations operations") + + def get_all_transformations(self) -> List[Transformation]: + """Get all transformations.""" + transformations_data = api_client.get_transformations() + # Convert API response to Transformation objects + transformations = [] + for trans_data in transformations_data: + transformation = Transformation( + name=trans_data["name"], + title=trans_data["title"], + description=trans_data["description"], + prompt=trans_data["prompt"], + apply_default=trans_data["apply_default"], + ) + transformation.id = trans_data["id"] + transformation.created = datetime.fromisoformat(trans_data["created"].replace('Z', '+00:00')) + transformation.updated = datetime.fromisoformat(trans_data["updated"].replace('Z', '+00:00')) + transformations.append(transformation) + return transformations + + def get_transformation(self, transformation_id: str) -> Transformation: + """Get a specific transformation.""" + trans_data = api_client.get_transformation(transformation_id) + transformation = Transformation( + name=trans_data["name"], + title=trans_data["title"], + description=trans_data["description"], + prompt=trans_data["prompt"], + apply_default=trans_data["apply_default"], + ) + transformation.id = trans_data["id"] + transformation.created = datetime.fromisoformat(trans_data["created"].replace('Z', '+00:00')) + transformation.updated = datetime.fromisoformat(trans_data["updated"].replace('Z', '+00:00')) + return transformation + + def create_transformation( + self, + name: str, + title: str, + description: str, + prompt: str, + apply_default: bool = False + ) -> Transformation: + """Create a new transformation.""" + trans_data = api_client.create_transformation( + name=name, + title=title, + description=description, + prompt=prompt, + apply_default=apply_default + ) + transformation = Transformation( + name=trans_data["name"], + title=trans_data["title"], + description=trans_data["description"], + prompt=trans_data["prompt"], + apply_default=trans_data["apply_default"], + ) + transformation.id = trans_data["id"] + transformation.created = datetime.fromisoformat(trans_data["created"].replace('Z', '+00:00')) + transformation.updated = datetime.fromisoformat(trans_data["updated"].replace('Z', '+00:00')) + return transformation + + def update_transformation(self, transformation: Transformation) -> Transformation: + """Update a transformation.""" + updates = { + "name": transformation.name, + "title": transformation.title, + "description": transformation.description, + "prompt": transformation.prompt, + "apply_default": transformation.apply_default, + } + trans_data = api_client.update_transformation(transformation.id, **updates) + + # Update the transformation object with the response + transformation.name = trans_data["name"] + transformation.title = trans_data["title"] + transformation.description = trans_data["description"] + transformation.prompt = trans_data["prompt"] + transformation.apply_default = trans_data["apply_default"] + transformation.updated = datetime.fromisoformat(trans_data["updated"].replace('Z', '+00:00')) + + return transformation + + def delete_transformation(self, transformation_id: str) -> bool: + """Delete a transformation.""" + api_client.delete_transformation(transformation_id) + return True + + def execute_transformation( + self, + transformation_id: str, + input_text: str, + model_id: str + ) -> Dict[str, str]: + """Execute a transformation on input text.""" + result = api_client.execute_transformation( + transformation_id=transformation_id, + input_text=input_text, + model_id=model_id + ) + return result + + +# Global service instance +transformations_service = TransformationsService() \ No newline at end of file diff --git a/app_home.py b/app_home.py index 4921424..b78e236 100644 --- a/app_home.py +++ b/app_home.py @@ -1,14 +1,14 @@ +import asyncio + +import nest_asyncio import streamlit as st from dotenv import load_dotenv from open_notebook.domain.base import ObjectModel + +nest_asyncio.apply() from open_notebook.exceptions import NotFoundError -from pages.components import ( - note_panel, - source_embedding_panel, - source_insight_panel, - source_panel, -) +from pages.components import note_panel, source_insight_panel, source_panel from pages.stream_app.utils import setup_page load_dotenv() @@ -19,11 +19,6 @@ if "object_id" not in st.query_params: st.stop() object_id = st.query_params["object_id"] -try: - obj = ObjectModel.get(object_id) -except NotFoundError: - st.switch_page("pages/2_📒_Notebooks.py") - st.stop() obj_type = object_id.split(":")[0] @@ -33,5 +28,3 @@ elif obj_type == "source": source_panel(object_id) elif obj_type == "source_insight": source_insight_panel(object_id) -elif obj_type == "source_embedding": - source_embedding_panel(object_id) diff --git a/commands/__init__.py b/commands/__init__.py new file mode 100644 index 0000000..e50e558 --- /dev/null +++ b/commands/__init__.py @@ -0,0 +1,10 @@ +"""Surreal-commands integration for Open Notebook""" + +from .example_commands import analyze_data_command, process_text_command +from .podcast_commands import generate_podcast_command + +__all__ = [ + "generate_podcast_command", + "process_text_command", + "analyze_data_command", +] diff --git a/commands/example_commands.py b/commands/example_commands.py new file mode 100644 index 0000000..5d8eafa --- /dev/null +++ b/commands/example_commands.py @@ -0,0 +1,149 @@ +from surreal_commands import command +from pydantic import BaseModel +from typing import Optional, List +from loguru import logger +import asyncio +import time + +# Add debugging to see if this module is being imported +logger.info("=== IMPORTING example_commands.py ===") +logger.info("Registering commands...") + +class TextProcessingInput(BaseModel): + text: str + operation: str = "uppercase" # uppercase, lowercase, word_count, reverse + delay_seconds: Optional[int] = None # For testing async behavior + +class TextProcessingOutput(BaseModel): + success: bool + original_text: str + processed_text: Optional[str] = None + word_count: Optional[int] = None + processing_time: float + error_message: Optional[str] = None + +class DataAnalysisInput(BaseModel): + numbers: List[float] + analysis_type: str = "basic" # basic, detailed + delay_seconds: Optional[int] = None + +class DataAnalysisOutput(BaseModel): + success: bool + analysis_type: str + count: int + sum: Optional[float] = None + average: Optional[float] = None + min_value: Optional[float] = None + max_value: Optional[float] = None + processing_time: float + error_message: Optional[str] = None + +@command("process_text", app="open_notebook") +async def process_text_command(input_data: TextProcessingInput) -> TextProcessingOutput: + """ + Example command for text processing. Tests basic command functionality + and demonstrates different processing types. + """ + start_time = time.time() + + try: + logger.info(f"Processing text with operation: {input_data.operation}") + + # Simulate processing delay if specified + if input_data.delay_seconds: + await asyncio.sleep(input_data.delay_seconds) + + processed_text = None + word_count = None + + if input_data.operation == "uppercase": + processed_text = input_data.text.upper() + elif input_data.operation == "lowercase": + processed_text = input_data.text.lower() + elif input_data.operation == "reverse": + processed_text = input_data.text[::-1] + elif input_data.operation == "word_count": + word_count = len(input_data.text.split()) + processed_text = f"Word count: {word_count}" + else: + raise ValueError(f"Unknown operation: {input_data.operation}") + + processing_time = time.time() - start_time + + return TextProcessingOutput( + success=True, + original_text=input_data.text, + processed_text=processed_text, + word_count=word_count, + processing_time=processing_time + ) + + except Exception as e: + processing_time = time.time() - start_time + logger.error(f"Text processing failed: {e}") + return TextProcessingOutput( + success=False, + original_text=input_data.text, + processing_time=processing_time, + error_message=str(e) + ) + +@command("analyze_data", app="open_notebook") +async def analyze_data_command(input_data: DataAnalysisInput) -> DataAnalysisOutput: + """ + Example command for data analysis. Tests command with complex input/output + and demonstrates error handling. + """ + start_time = time.time() + + try: + logger.info(f"Analyzing {len(input_data.numbers)} numbers with {input_data.analysis_type} analysis") + + # Simulate processing delay if specified + if input_data.delay_seconds: + await asyncio.sleep(input_data.delay_seconds) + + if not input_data.numbers: + raise ValueError("No numbers provided for analysis") + + count = len(input_data.numbers) + sum_value = sum(input_data.numbers) + average = sum_value / count + min_value = min(input_data.numbers) + max_value = max(input_data.numbers) + + processing_time = time.time() - start_time + + return DataAnalysisOutput( + success=True, + analysis_type=input_data.analysis_type, + count=count, + sum=sum_value, + average=average, + min_value=min_value, + max_value=max_value, + processing_time=processing_time + ) + + except Exception as e: + processing_time = time.time() - start_time + logger.error(f"Data analysis failed: {e}") + return DataAnalysisOutput( + success=False, + analysis_type=input_data.analysis_type, + count=0, + processing_time=processing_time, + error_message=str(e) + ) + +# Add debugging to confirm commands are registered +logger.info("✅ Commands registered: process_text and analyze_data") +logger.info("=== FINISHED IMPORTING example_commands.py ===") + +# Let's also verify what the registry contains +try: + from surreal_commands import registry + commands = registry.list_commands() + logger.info(f"Registry after import: {commands}") +except Exception as e: + logger.error(f"Error checking registry: {e}") \ No newline at end of file diff --git a/commands/podcast_commands.py b/commands/podcast_commands.py new file mode 100644 index 0000000..adf0c7e --- /dev/null +++ b/commands/podcast_commands.py @@ -0,0 +1,195 @@ +import time +from pathlib import Path +from typing import Optional + +from loguru import logger +from pydantic import BaseModel +from surreal_commands import CommandInput, CommandOutput, command + +from open_notebook.config import DATA_FOLDER +from open_notebook.database.repository import ensure_record_id, repo_query +from open_notebook.domain.podcast import EpisodeProfile, PodcastEpisode, SpeakerProfile + +try: + from podcast_creator import configure, create_podcast +except ImportError as e: + logger.error(f"Failed to import podcast_creator: {e}") + raise ValueError("podcast_creator library not available") + + +# Add debugging to see if this module is being imported +logger.info("=== IMPORTING podcast_commands.py ===") +logger.info("Registering podcast commands...") + + +def full_model_dump(model): + if isinstance(model, BaseModel): + return model.model_dump() + elif isinstance(model, dict): + return {k: full_model_dump(v) for k, v in model.items()} + elif isinstance(model, list): + return [full_model_dump(item) for item in model] + else: + return model + + +class PodcastGenerationInput(CommandInput): + episode_profile: str + speaker_profile: str + episode_name: str + content: str + briefing_suffix: Optional[str] = None + + +class PodcastGenerationOutput(CommandOutput): + success: bool + episode_id: Optional[str] = None + audio_file_path: Optional[str] = None + transcript: Optional[dict] = None + outline: Optional[dict] = None + processing_time: float + error_message: Optional[str] = None + + +@command("generate_podcast", app="open_notebook") +async def generate_podcast_command( + input_data: PodcastGenerationInput, +) -> PodcastGenerationOutput: + """ + Real podcast generation using podcast-creator library with Episode Profiles + """ + start_time = time.time() + + try: + logger.info( + f"Starting podcast generation for episode: {input_data.episode_name}" + ) + logger.info(f"Using episode profile: {input_data.episode_profile}") + + # 1. Load Episode and Speaker profiles from SurrealDB + episode_profile = await EpisodeProfile.get_by_name(input_data.episode_profile) + if not episode_profile: + raise ValueError( + f"Episode profile '{input_data.episode_profile}' not found" + ) + + speaker_profile = await SpeakerProfile.get_by_name( + episode_profile.speaker_config + ) + if not speaker_profile: + raise ValueError( + f"Speaker profile '{episode_profile.speaker_config}' not found" + ) + + logger.info(f"Loaded episode profile: {episode_profile.name}") + logger.info(f"Loaded speaker profile: {speaker_profile.name}") + + # 3. Load all profiles and configure podcast-creator + episode_profiles = await repo_query("SELECT * FROM episode_profile") + speaker_profiles = await repo_query("SELECT * FROM speaker_profile") + + # Transform the surrealdb array into a dictionary for podcast-creator + episode_profiles_dict = { + profile["name"]: profile for profile in episode_profiles + } + speaker_profiles_dict = { + profile["name"]: profile for profile in speaker_profiles + } + + # 4. Generate briefing + briefing = episode_profile.default_briefing + if input_data.briefing_suffix: + briefing += f"\n\nAdditional instructions: {input_data.briefing_suffix}" + + # Create the a record for the episose and associate with the ongoing command + episode = PodcastEpisode( + name=input_data.episode_name, + episode_profile=full_model_dump(episode_profile.model_dump()), + speaker_profile=full_model_dump(speaker_profile.model_dump()), + command=ensure_record_id(input_data.execution_context.command_id) + if input_data.execution_context + else None, + briefing=briefing, + content=input_data.content, + audio_file=None, + transcript=None, + outline=None, + ) + await episode.save() + + configure("speakers_config", {"profiles": speaker_profiles_dict}) + configure("episode_config", {"profiles": episode_profiles_dict}) + + logger.info("Configured podcast-creator with episode and speaker profiles") + + logger.info(f"Generated briefing (length: {len(briefing)} chars)") + + # 5. Create output directory + output_dir = Path(f"{DATA_FOLDER}/podcasts/episodes/{input_data.episode_name}") + output_dir.mkdir(parents=True, exist_ok=True) + + logger.info(f"Created output directory: {output_dir}") + + # 6. Generate podcast using podcast-creator + logger.info("Starting podcast generation with podcast-creator...") + + result = await create_podcast( + content=input_data.content, + briefing=briefing, + episode_name=input_data.episode_name, + output_dir=str(output_dir), + speaker_config=speaker_profile.name, + episode_profile=episode_profile.name, + ) + + episode.audio_file = ( + str(result.get("final_output_file_path")) if result else None + ) + episode.transcript = { + "transcript": full_model_dump(result["transcript"]) if result else None + } + episode.outline = full_model_dump(result["outline"]) if result else None + await episode.save() + + processing_time = time.time() - start_time + logger.info( + f"Successfully generated podcast episode: {episode.id} in {processing_time:.2f}s" + ) + + return PodcastGenerationOutput( + success=True, + episode_id=str(episode.id), + audio_file_path=str(result.get("final_output_file_path")) + if result + else None, + transcript={"transcript": full_model_dump(result["transcript"])} + if result.get("transcript") + else None, + outline=full_model_dump(result["outline"]) + if result.get("outline") + else None, + processing_time=processing_time, + ) + + except Exception as e: + processing_time = time.time() - start_time + logger.error(f"Podcast generation failed: {e}") + logger.exception(e) + + return PodcastGenerationOutput( + success=False, processing_time=processing_time, error_message=str(e) + ) + + +# Add debugging to confirm commands are registered +logger.info("✅ Podcast commands registered: generate_podcast") +logger.info("=== FINISHED IMPORTING podcast_commands.py ===") + +# Let's also verify what the registry contains +try: + from surreal_commands import registry + + commands = registry.list_commands() + logger.info(f"Registry after podcast import: {commands}") +except Exception as e: + logger.error(f"Error checking registry: {e}") diff --git a/docker-compose.single.yml b/docker-compose.single.yml new file mode 100644 index 0000000..662ed02 --- /dev/null +++ b/docker-compose.single.yml @@ -0,0 +1,20 @@ +services: + open_notebook_single: + image: lfnovo/open_notebook:latest-single + build: + context: . + dockerfile: Dockerfile.single + ports: + - "8502:8502" # Streamlit UI + - "5055:5055" # REST API + env_file: + - ./docker.env + volumes: + - ./notebook_data:/app/data # Application data + - ./surreal_single_data:/mydata # SurrealDB data + restart: always + # Single container includes all services: SurrealDB, API, Worker, and Streamlit + # Access: + # - Streamlit UI: http://localhost:8502 + # - REST API: http://localhost:5055 + # - API Documentation: http://localhost:5055/docs \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml index 7fa5349..fd0853d 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -1,12 +1,6 @@ -# Instructions on how to use the different compose profiles -# 1. Run `docker compose --profile single up` to start the app and database on the same container -# 2. Run `docker compose --profile multi up` to start the multi container with app and database separate -# 3. Run `docker compose --profile db_only up` to start the database only -- useful if developing locally services: surrealdb: image: surrealdb/surrealdb:v2 - ports: - - "8000:8000" volumes: - ./surreal_data:/mydata environment: @@ -14,7 +8,7 @@ services: command: start --log info --user root --pass root rocksdb:/mydata/mydatabase.db pull_policy: always user: root - profiles: [db_only, multi] + restart: always open_notebook: image: lfnovo/open_notebook:latest ports: @@ -24,18 +18,6 @@ services: depends_on: - surrealdb pull_policy: always - profiles: [multi] volumes: - ./notebook_data:/app/data - open_notebook_single: - build: - context: . - dockerfile: Dockerfile.single - ports: - - "8080:8502" - profiles: - - single - volumes: - - ./.docker_data/data:/app/data - - ./docker2.env:/app/.env - - ./google-credentials.json:/app/google-credentials.json + restart: always diff --git a/docs/PODCASTS.md b/docs/PODCASTS.md deleted file mode 100644 index cabbea6..0000000 --- a/docs/PODCASTS.md +++ /dev/null @@ -1,2 +0,0 @@ - -This page has moved to: [https://www.open-notebook.ai/features/podcast.html](https://www.open-notebook.ai/features/podcast.html) \ No newline at end of file diff --git a/docs/SETUP.md b/docs/SETUP.md deleted file mode 100644 index 652314a..0000000 --- a/docs/SETUP.md +++ /dev/null @@ -1 +0,0 @@ -This page moved to: [https://www.open-notebook.ai/get-started.html](https://www.open-notebook.ai/get-started.html) \ No newline at end of file diff --git a/docs/TRANSFORMATIONS.md b/docs/TRANSFORMATIONS.md index 2ca1041..e1ef180 100644 --- a/docs/TRANSFORMATIONS.md +++ b/docs/TRANSFORMATIONS.md @@ -1 +1,49 @@ -This page moved to: [https://www.open-notebook.ai/features/transformations.html](https://www.open-notebook.ai/features/transformations.html) \ No newline at end of file +# Transformations + +Transformations are a core concept within Open Notebook, providing a flexible and powerful way to generate new insights by applying a series of processing steps to your content. Inspired on the [Fabric framework](https://github.com/danielmiessler/fabric), Transformations allow you to customize how information is distilled, summarized, and enriched, opening up new ways to understand and engage with your research. + +## What is a Transformation? + +A **Transformation** modifies text input to produce a different output. Whether you're summarizing an article, generating key insights, or creating reflective questions, Transformations allow you to automate and enrich the processing of your content. + +## Creating a Transformation + +You can edit the default transformations or create your own in the Transformations UI. +![New Notebook](/assets/new_transformation.png) + +When setting up the transformation, you need to configure: + +- Name (just for your reference) +- Title (will be the title of all cards created by the transformation) +- Description (will be shown as a hint in the UI) +- Prompt (the actual prompt that will be applied) +- Apply Default (will suggest this transformation for all new sources) + +### Default Transformation Prompt + +In this page, you can also change the Default Transformation Prompt which is a text that will be prepended to all transformations. This is useful to set up common instructions that you want to apply to all transformations, such as tone, style, or specific requirements. The default value also has some instructions to prevent the model from refusing to act due to copyright. + + +## Using Transformations + +Your custom Patterns automatically appear on the Sources page in Open Notebook. Select and apply them to your content as you research and explore. Note patterns will be added soon, enabling transformation of both sources and personal notes. + + +## Experimenting different transformations and models + +In the Playground page, you'll be able to choose from your installed models and defined transformations and see how they compare. Use this feature to test your transformation prompts to achieve your desired effect. + +## Sky's the Limit + +Transformations empower you to create personalized, powerful workflows that bring out the most meaningful insights from your content. Whether you're working with articles, papers, notes, or other media, you can craft specific and meaningful outcomes tailored to your research goals. + + \ No newline at end of file diff --git a/docs/USAGE.md b/docs/USAGE.md deleted file mode 100644 index 411780e..0000000 --- a/docs/USAGE.md +++ /dev/null @@ -1,2 +0,0 @@ -This page moved to: [http://www.open-notebook.ai/features/basic-workflow.html](http://www.open-notebook.ai/features/basic-workflow.html) -Also check: [http://www.open-notebook.ai/features.html](http://www.open-notebook.ai/features.html) \ No newline at end of file diff --git a/docs/ai-notes.md b/docs/ai-notes.md new file mode 100644 index 0000000..acb97cf --- /dev/null +++ b/docs/ai-notes.md @@ -0,0 +1,27 @@ +# AI-Powered Notes + +Writing notes has never been easier or more insightful with Open Notebook's AI-powered note-taking feature. You can write your own notes, or let the AI assist you by generating summaries, highlighting key points, or suggesting new insights based on your research materials. This feature allows you to save time while ensuring you don't miss out on important information, making your note-taking process both efficient and enriched by AI support. + +## Creating Notes + +There are 3 ways you can build your notes right now: + +### Manual Notes + +Inside any Notebook page, you will find a whole column dedicated to your notes. Just click the "Add Note" button, type a title and message and you are done. + +### From an Insight + +When you generate a Source Insight, you can easily convert it into a note by clicking the "Save as Note" button. This will automatically create a new note with the insight's content, which you can then edit or expand upon as needed. + +### From the AI chat + +If you are talking to the AI assistant and find a message that is useful to save as a Note, just click on the "Save as Note" button and it will be saved as a new note. + +![AI Notes](/assets/ai_note.png) + +## A lot more coming soon + +Notes are a very important part of the learning workflow and will be the focus of many of our new releases. One of the things we are working on is a Canvas-like interface for notes so that you can collaborate with the AI on the same piece of text. + +We also plan to make this a real Zettelkasten workflow by enabling you to link notes, find similar ideias, and many other things. If any any ideas of different useful ways to interact with your notes, please [let us know](https://github.com/lfnovo/open-notebook/discussions/categories/ideas). \ No newline at end of file diff --git a/docs/basic-workflow.md b/docs/basic-workflow.md new file mode 100644 index 0000000..2bb67b6 --- /dev/null +++ b/docs/basic-workflow.md @@ -0,0 +1,64 @@ +# Using Open Notebook + +This first release of Open Notebook is inspired by Notebook LM, so you will find a very similar workflow. + +## Creating a new notebook + +![New Notebook](/assets/new_notebook.png) + +Just type a name and description for the Notebook and you are good to go. Make the description as detailed as possible since it will be used by the LLM to understand the context of the notebook and provide you with better answers. + +## Adding sources + +Just click on Add Source and enter the URL, upload the file or paste the content of your source. + +![New Notebook](/assets/add_source.png) + +You'll find your new source in the first column of the Notebook Page. + +![New Notebook](/assets/asset_list.png) + +## Using transformations + +Once you have your sources created, you can start gathering insights from them using [transformations](/features/transformations.html). +Create your own prompts and generate the wisdom that makes sense to you. + +![New Notebook](/assets/transformations.png) + +## Talk to the Assistant + +Once you have enough content in the notebook, you can decide which of them will be visible to LLM before sending your question. + +![New Notebook](/assets/context.png) + +- Not in Context: LLM won't get this as part of the context +- Summary: LLM will get the summary for the content and can ask for the full document if desired +- Full Content: LLM will receive the full transcript of the content together with your question. + +It's recommended that you use the least amount of context so that you can save up on your API spend. + +## Making Notes + +There is 2 ways you can make notes: + +Manually by clicking on New Note + +![New Notebook](/assets/human_note.png) + +Or by turning any LLM message into a Note. + +![New Notebook](/assets/ai_note.png) + +## Generate your podcasts + +Once you have your content ready, start creating beautiful podcast episodes from it. + +![Context](/assets/podcast_listen.png) + +See more at the [Podcasts](/features/podcast.html) section. + +## Searching + +The search page gives you a glance of all the notes you have made and the sources you have added. You can query the database both by keyword as well as using the vector search. + +![New Notebook](/assets/search.png) \ No newline at end of file diff --git a/docs/chat-assistant.md b/docs/chat-assistant.md new file mode 100644 index 0000000..f3f4a95 --- /dev/null +++ b/docs/chat-assistant.md @@ -0,0 +1,13 @@ +# Chat Assistant + +Open Notebook's Chat Assistant provides an intelligent interface for interacting with your research notes and data. It can help analyze your content, answer questions, and provide insights while respecting your privacy preferences. The assistant leverages AI capabilities while giving you full control over how much context and information you want to share. + +## Context Management + +Privacy and control are at the heart of Open Notebook. With Fine-Grained Context Management, you have complete control over what information is shared with the AI assistant. You can choose to share no context, summaries only, or full content, allowing you to balance privacy, performance, and cost. This ensures that your interactions with AI are fully transparent and that you only share what you're comfortable with, maintaining both your privacy and the integrity of your research. + +![Search](/assets/context.png) + +## Multple Chats + +You can maintain multiple separate chat threads for different topics or research areas within the same notebook. Each chat maintains its own context and history, allowing you to organize conversations by subject matter, project, or any other criteria. This helps keep discussions focused and makes it easier to track different lines of inquiry or analysis. \ No newline at end of file diff --git a/docs/content-support.md b/docs/content-support.md new file mode 100644 index 0000000..b2804ac --- /dev/null +++ b/docs/content-support.md @@ -0,0 +1,123 @@ +# Content Integration + +Open Notebook provides comprehensive support for various content formats, making it your central hub for all research materials. + +
    +
    +
    📄
    +

    Documents

    +
      +
    • PDF, Epub
      • +
    • Text, Markdown
      • +
    • Office files
      • +
    +
    + +
    +
    🎥
    +

    Media

    +
      +
    • YouTube videos
      • +
    • Local video files
      • +
    • Audio recordings
      • +
    +
    + +
    +
    🌐
    +

    Web Content

    +
      +
    • Web articles
      • +
    • Blog posts
      • +
    • News articles
      • +
    +
    +
    + +## How each content is processed + +### Link Processing + +Add a URL to any website and the tool will scrape its content for you. This can be done through a simple HTTP request or through more powerful tools like Firecrawl or Jina. + +### Youtube Transcripts + +Add a URL for an Youtube video and we'll extract the transcript. + +### PDF, DOC, PPT, ePub + +Those documents will be processed and their text extract. This is done using [Docling](https://docling-project.github.io/) by default, by can be changed to a light-weight alternative, if needed. + +**Roadmap:** improvements to tables in PDFs and use of Vision model for images + +### Video / Audio processing + +Videos are converted to audio files before processing. +Audio files are processed for transcript extraction and the transcript text is saved. + +**Roadmap:** We might add support for Gemini video understanding capabilities at some point. + +:::info More Formats Coming Soon +We're constantly working on adding support for more content types and formats. Have a specific format in mind? [Share your suggestions](https://github.com/lfnovo/open_notebook/discussions/categories/ideas) in our GitHub discussions! +::: + +## Embeddings + +When you upload new content to the platform, you have the option to enable embedding for that content. This will trigger a process that consists of generating chunks of 1000 words and embedding them using the model of your choice. This enables the content to appear in searches when the model is doing research for you through the [Ask feature](/features/search.html). + +Although this is not necessary for you to use the app, it will greatly improve your experience and it is pretty cheap to use. + +- text-embedding-3-small (Open AI): $0.020 / 1M tokens +- text-embedding-004 (Gemini): $0.012 / 1M tokens - large free tier available +- free with Ollama models, like mxbai-embed-large + + \ No newline at end of file diff --git a/docs/model-providers.md b/docs/model-providers.md new file mode 100644 index 0000000..aa55b36 --- /dev/null +++ b/docs/model-providers.md @@ -0,0 +1,180 @@ +# Model Provider Support + +Open Notebook supports multiple AI model providers, giving you flexibility in choosing the AI that best fits your needs. This page combines a high-level overview with detailed recommendations to help you pick the right models for your workflow. + +## Understanding Model Types + +Open Notebook uses four types of AI models: + +- **Language Models**: For chat, text generation, summaries, and tool calling +- **Embedding Models**: For semantic search and content similarity +- **Text-to-Speech (TTS)**: For generating podcasts and audio content +- **Speech-to-Text (STT)**: For transcribing audio files + +## What to Consider When Choosing Models + +- **💰 Cost**: Some models are free (Ollama), others charge per token +- **🎯 Quality**: Higher quality models often cost more but produce better results +- **⚡ Speed**: Smaller models are faster but may be less capable +- **🔧 Features**: Some models excel at specific tasks like tool calling or large contexts + +## Provider Highlights and Recommendations + +| Provider | Highlights & Best Use Cases | +|-------------|------------------------------------------------------------------------------------------------------------| +| **OpenAI** | Reliable performance, excellent tool calling, wide ecosystem support. Recommended: `gpt-4o`, `gpt-4o-mini`, `whisper-1` (STT), `tts-1` (TTS), `text-embedding-3-small` (Embedding) | +| **Anthropic** | Exceptional reasoning, especially with Sonnet 3.5. Recommended: `claude-3-5-sonnet-latest` (Chat/Tools) | +| **Gemini (Google)** | Large context (up to 2M tokens), affordable high-quality models. Recommended: `gemini-2.0-flash`, `gemini-2.5-pro-preview-06-05` (Language), `gemini-2.5-flash-preview-tts` (TTS), `text-embedding-004` (Embedding) | +| **Ollama** | Free, local models. Great for experimentation and transformation tasks. Recommended: `gemma3`, `qwen3`, `phi4`, `deepseek-r1`, `llama4` (Language), `mxbai-embed-large` (Embedding) | +| **ElevenLabs** | High-quality voice synthesis and transcription. Recommended: `eleven-monolingual-v1`, `eleven-multilingual-v2` (TTS), `eleven-stt-v1` (STT) | +| **Open Router** | Access to several open source models, Cohere, Mistral, xAI, etc. | +| **Groq** | Very fast inference, but limited model availability. | +| **xAI** | Powerful Grok model, less guardrails, great responses. Recommended: `grok-3`, `grok-3-mini` | +| **Vertex** | For Google Cloud environments. | +| **Voyage** | Specialized embedding models. Recommended: `voyage-3.5-lite` (Embedding) | +| **Mistral** | European-based, cost-effective, strong language and embedding models. Recommended: `mistral-medium-latest`, `ministral-8b-latest` (Language), `mistral-embed` (Embedding) | +| **Deepseek** | Cost-effective language models. Recommended: `deepseek-chat` (Language) | + + +--- + +### Provider-Specific Model Recommendations + +**Google (Gemini):** +- Language: `gemini-2.0-flash`, `gemini-2.5-pro-preview-06-05` +- TTS: `gemini-2.5-flash-preview-tts`, `gemini-2.5-pro-preview-tts` +- Embedding: `text-embedding-004` + +**OpenAI:** +- Language: `gpt-4o-mini`, `gpt-4o` +- TTS: `tts-1`, `gpt-4o-mini-tts` +- STT: `whisper-1` +- Embedding: `text-embedding-3-small` + +**ElevenLabs:** +- TTS: `eleven-monolingual-v1`, `eleven-multilingual-v2`, `eleven_turbo_v2_5` +- STT: `eleven-stt-v1`, `scribe_v1` + +**Anthropic:** +- Language: `claude-3-5-sonnet-latest` + +**xAI:** +- Language: `grok-3`, `grok-3-mini` + +**Ollama:** +- Language: `gemma3`, `qwen3`, `phi4`, `deepseek-r1`, `llama4` +- Embedding: `mxbai-embed-large` + +**Voyage:** +- Embedding: `voyage-3.5-lite` + +**Mistral:** +- Language: `mistral-medium-latest`, `ministral-8b-latest` +- Embedding: `mistral-embed` + +**Deepseek:** +- Language: `deepseek-chat` + +--- + +All providers are installed out of the box. All you need to do is to setup the environment variable configurations (API Keys, etc) for your selected provider and decide which models to use. + +Please refer to the [`.env.example`](https://github.com/lfnovo/open-notebook/blob/main/.env.example) file for instructions on which ENV variables are necessary for each. + + +### Create models on the Settings page + +Go to the settings page and create your different models. + +> 📝 **Notice:** For complete usage of all the features, you need to setup at least 4 models (one of each type). + +| Model Type | Supported Providers | +|-------------------|-----------------------------------------------------------------------| +| Language | OpenAI, Anthropic, Open Router, LiteLLM, Vertex AI, Gemini, Ollama, xAI, Groq, Mistral, Deepseek | +| Embedding | OpenAI, Gemini, Vertex AI, Ollama, Mistral | +| Speech to Text | OpenAI, Groq, ElevenLabs | +| Text to Speech | OpenAI, ElevenLabs, Gemini, Vertex | + +If you are not sure which models to setup, the Model Settings page will offer some options for you to get started with. + +After setting up the models, head to the Model Defaults tab to define the default models. There are several defaults to setup: + +| Model Default | Purpose | +|--------------------|----------------------------------------------| +| Chat Model | Will be used on all chats | +| Transformation Model | Will be used for summaries, insights, etc | +| Large Context | For content higher than 110k tokens (use Gemini here) | +| Speech to Text | For transcribing text from your audio/video uploads | +| Text to Speech | For generating podcasts | +| Embedding | For creating vector representation of content | + +All model types and defaults are required for now. If you are not sure which to pick, go with OpenAI, the only one that covers all possible model types. + +The reason for opting for this route is because different LLMs will behave better/worse depending on the type of request and type of tools offered. So it makes sense to build a more refined system to decide which model should process which task. + +For instance, you can use an Ollama-based model, like `gemma3`, to do summarization and document query, and use OpenAI/Claude for chat. The whole idea is to allow you to experiment on cost/performance. + +## Suggested Model Combinations + +Here are some ready-to-use combinations for different tasks: + +- **Chat**: `claude-3-5-sonnet-latest` (Anthropic) or `grok-3` (xAI) - Exceptional reasoning +- **Tools**: `gpt-4o` (OpenAI) or `claude-3-5-sonnet-latest` (Anthropic) or `grok-3` (xAI) - Best tool calling +- **Transformations**: `grok-3-mini` (xAI) - Smart and efficient +- **Large Context**: `gemini-2.5-pro-preview-06-05` (Google) - Premium quality +- **Embedding**: `voyage-3.5-lite` (Voyage) - Specialized performance + +We are working hard to support more providers and model types to give users more flexibility and options. + +These are some suggested configurations for different use cases and budgets: + +### Best in Class + +| Model Default | Model Name | +|------------|-----------| +| Chat Model | claude-3-5-sonnet-latest | +| Transformation Model | gpt-4o-mini | +| Large Context | gemini-1.5-pro | +| Speech to Text | whisper-1 | +| Text to Speech | eleven_turbo_v2_5 (elevenlabs) | +| Embedding | text-embedding-3-small | + +### Open AI Only Configuration + +| Model Default | Model Name | +|------------|-----------| +| Chat Model | gpt-4o-mini | +| Transformation Model | gpt-4o-mini | +| Large Context | gpt-4o-mini (you will be limited to 128k tokens) | +| Speech to Text | whisper-1 | +| Text to Speech | tts-1-hd | +| Embedding | text-embedding-3-small | + + +### Gemini Only Configuration + +| Model Default | Model Name | +|------------|-----------| +| Chat Model | gemini-1.5-flash | +| Transformation Model | gemini-1.5-flash | +| Large Context | gemini-1.5-pro | +| Speech to Text | (not available yet) | +| Text to Speech | default | +| Embedding | text-embedding-004 | + +### Open Source Only (using Ollama) + +| Model Default | Model Name | +|------------|-----------| +| Chat Model | qwen2.5 or gemma2 or phi3 or llama3.2 | +| Transformation Model |qwen2.5 or gemma2 or phi3 or llama3.2 | +| Large Context |qwen2.5 or gemma2 or phi3 or llama3.2 (limited to 128k) | +| Speech to Text | (not possible yet) | +| Text to Speech | (not possible yet) | +| Embedding | mxbai-embed-large | + +We are working hard to support more providers and model types to give users more flexibility and options. + +## Testing your models + +If you are not sure which model will work best for you, you can try them up on the Playground section and see for yourself how they handle different tasks. diff --git a/docs/models.md b/docs/models.md index 41614f3..e45cadd 100644 --- a/docs/models.md +++ b/docs/models.md @@ -243,5 +243,4 @@ To use the Google Cloud (Vertex) provider for audio: 2. pass the following Environment Variables - VERTEX_PROJECT=your-google-cloud-project-name - GOOGLE_APPLICATION_CREDENTIALS=./google-credentials.json - - VERTEX_LOCATION=your-google-cloud-project-location -3. Setup the correct permissions in the [Google Cloud Console](https://github.com/souzatharsis/podcastfy/blob/main/usage/config.md) \ No newline at end of file + - VERTEX_LOCATION=your-google-cloud-project-location \ No newline at end of file diff --git a/docs/podcast.md b/docs/podcast.md new file mode 100644 index 0000000..6dd0c04 --- /dev/null +++ b/docs/podcast.md @@ -0,0 +1,166 @@ +# Podcast Generator + +Open Notebook's Podcast Generator creates professional, multi-speaker podcasts from your research content. With our Episode Profile system, you can generate high-quality podcasts in just 3 clicks - no complex configuration required. + +**🎯 More Flexible**: Unlike Google Notebook LM's fixed 2-host format, Open Notebook supports **1-4 speakers** with complete customization of personalities, voices, and conversation styles. + +## 🎬 3-Click Podcast Generation + +### Step 1: Choose Episode Profile +Select from pre-configured podcast styles: +- **Tech Discussion**: 2 technical experts discussing complex topics +- **Solo Expert**: Single expert explaining concepts in an accessible way +- **Business Analysis**: Business-focused panel discussion +- **Interview Style**: Host interviewing a subject matter expert + +Or configure your own. + +### Step 2: Name Your Episode +Give your podcast a descriptive name that reflects the content. + +### Step 3: Generate +Click "Generate Podcast" and continue using Open Notebook while your podcast processes in the background (2-3 minutes). + +![Podcast Generation](/assets/podcast.png) + +## 🎙️ Episode Profiles vs Traditional Setup + +**Before (15+ Fields)**: +- Manual speaker role configuration +- Complex conversation style settings +- Detailed voice and personality setup +- Dialogue structure customization +- Provider and model selection + +**Now (Episode Profiles)**: +- Pre-configured professional templates +- Optimized speaker combinations +- Battle-tested conversation flows +- One-click generation with optional customization + +## 🔄 Background Processing + +### Non-Blocking Experience +- Podcasts generate in the background +- Continue your research while processing +- Simple status tracking without complexity +- Desktop notifications when complete + +### Job Status Tracking +Monitor your podcast generation: +- **Pending**: Job queued for processing +- **Running**: Currently generating (outline → transcript → audio) +- **Completed**: Ready to listen and download +- **Failed**: Error details for troubleshooting + +![Podcast Status](/assets/podcast_listen.png) + +## 🎨 Customization Options + +### Speaker Configurations +- **Solo Format**: Single expert with rich personality +- **Dual Speakers**: Two complementary perspectives +- **Panel Discussion**: 3-4 speakers with diverse viewpoints +- **Interview Style**: Host + guest dynamic + +### Voice & Personality +Each speaker profile includes: +- **Voice Selection**: Choose from multiple TTS providers +- **Personality Traits**: Optimized speaking styles +- **Backstory**: Rich character development +- **Role Definition**: Clear expert positioning + +### Content Adaptation +- **Automatic Briefing**: Context-aware content adaptation +- **Segment Structure**: Optimized for engagement +- **Conversation Flow**: Natural dialogue patterns +- **Fact Integration**: Seamless research incorporation + +## 🛠️ Advanced Features + +### Multi-Provider Support +Choose your preferred AI and TTS providers: +- **Language Models**: OpenAI, Anthropic, Google, Groq, Ollama +- **Text-to-Speech**: OpenAI, Google TTS, ElevenLabs +- **Local Processing**: Full Ollama support for privacy + +### Custom Episode Profiles +Create your own profiles by combining: +- Speaker configurations (1-4 speakers) +- AI model preferences +- Default briefing templates +- Segment count and structure + +### Episode Management +- **Library View**: All episodes organized by notebook +- **Audio Player**: Integrated playback with controls +- **Download Options**: Export MP3 for offline listening +- **Metadata**: Generation details and settings used + +## 📱 Mobile & Accessibility + +### Audio-First Design +Perfect for: +- Commuting and travel +- Exercise and walking +- Multitasking scenarios +- Visual accessibility needs + +### Quality Features +- **Professional Audio**: High-quality TTS with natural speech +- **Consistent Pacing**: Optimized for comprehension +- **Clear Diction**: Enhanced pronunciation and clarity +- **Background Processing**: No interruption to workflow + +## 🔧 Technical Architecture + +### Background Worker System +- **Async Processing**: Non-blocking podcast generation +- **Queue Management**: Reliable job processing +- **Error Recovery**: Automatic retry and detailed logging +- **Scalable Design**: Foundation for future features + +### Integration Points +- **Content Pipeline**: Seamless notebook content integration +- **Search Integration**: Generate podcasts from search results +- **Transformation System**: Part of larger content processing workflow +- **API Access**: Full programmatic control via REST API + +## 🎧 Sample Podcasts + +Listen to examples of what Open Notebook can create: + +[![Check out our podcast sample](https://img.youtube.com/vi/D-760MlGwaI/0.jpg)](https://www.youtube.com/watch?v=D-760MlGwaI) + +*Generated using custom Episode Profile with ElevenLabs voices and interview format* + +## 🚀 Getting Started + +1. **Setup**: Ensure you have API keys configured for your preferred providers +2. **Initialize**: Click "Initialize Default Profiles" on first use +3. **Select Content**: Choose notebook with research content +4. **Generate**: Pick profile → name episode → generate +5. **Listen**: Audio appears in episode list when complete + +## ⚡ Pro Tips + +### Content Optimization +- **Rich Source Material**: More content = better podcast discussions +- **Clear Topics**: Focused content creates more engaging conversations +- **Mixed Media**: Combine text, links, and documents for depth + +### Profile Selection +- **Tech Content**: Use "Tech Discussion" for technical deep-dives +- **Business Content**: Use "Business Analysis" for strategic discussions +- **Educational**: Use "Solo Expert" for clear explanations +- **General**: Use "Interview Style" for broad topic exploration + +### Workflow Integration +- **Research → Generate**: Create podcasts during active research +- **Review Sessions**: Generate summaries of completed research +- **Learning Path**: Create series with consistent Episode Profiles +- **Sharing**: Export episodes for team knowledge sharing + +--- + +*The Podcast Generator establishes Open Notebook as a superior alternative to Google Notebook LM with unmatched flexibility, quality, and user control.* \ No newline at end of file diff --git a/docs/search.md b/docs/search.md new file mode 100644 index 0000000..f253a47 --- /dev/null +++ b/docs/search.md @@ -0,0 +1,42 @@ +# Integrated Search Engines + +When it comes to managing information and learning, search plays a big role. Being able to find useful information and put it to use is one fhe most fundamental aspects of any succesfull knowledge strategy. + +We help you do that in 2 ways: + +## 1 - Search + +Open Notebook comes equipped with built-in full-text and vector search capabilities, enabling you to quickly find the information you need. The full-text search lets you search across all your notes and documents, while vector search allows for more context-based and semantic retrieval. This dual search capability ensures that you can find specific details or broad concepts with ease, streamlining your research process and saving valuable time. + +![Search](/assets/search.png) + +## 2 - Ask your Knowledge Base + +All your sources and notes are part of a huge knowledge source that you can tap into at any time. One of the most usefuls things to do with them is to have them available for the AI Assistant to query and ellaborate on. + +With the Ask feature, you can define a question, selected the LLM models you'd like to process and just relax until they do all the work. + +The process happens as follows: + +- AI will interpret your query and generate several searches to try to answer parts of it +- Each query will be processed and analyzed individually +- All queries are combined into one coherent answer. + +You can customize 3 models for processing the query: + +| Provider | Highlights | +|------------|-----------| +| Query Strategy | Decides what to search for in order to reply. You should use a powerful model here like Claude Sonnet, GPT-4o, Llama 3.2, Gemini Pro or Grok | +| Individual Answer | Each query gets processed by its own AI model to generate a subpart of the answer. You can use cheaper/faster models here like gpt-4o-mini, Gemini Flash or Ollama models | +| Final Answer | This is the model that combines all individual answers into a single response. Use a powerful model here for best results. | + +![Ask](/assets/ask.png) + + +### Citations + +The answers will also include a link to the document where its facts came from, so can you check the reference of what's been presented. + +![Answer](/assets/ask_answer.png) + + diff --git a/docs/security.md b/docs/security.md new file mode 100644 index 0000000..305ae75 --- /dev/null +++ b/docs/security.md @@ -0,0 +1,133 @@ +# Security + +Open Notebook includes optional password protection for users who need to deploy their instances publicly. + +## Password Protection + +### When to Use Password Protection + +- **Public Hosting**: When deploying on cloud services like PikaPods, DigitalOcean, AWS, etc. +- **Shared Networks**: When running on networks where others might access your instance +- **Team Deployments**: When multiple people need controlled access to the same instance + +### When NOT to Use Password Protection + +- **Local Development**: When running on your local machine for personal use +- **Private Networks**: When running on secure, private networks +- **Single User**: When you're the only person with access to the machine + +## Setup + +### 1. Environment Configuration + +Add the password to your environment configuration: + +**For regular deployment:** +```bash +# In your .env file +OPEN_NOTEBOOK_PASSWORD=your_secure_password_here +``` + +**For Docker deployment:** +```bash +# In your docker.env file +OPEN_NOTEBOOK_PASSWORD=your_secure_password_here +``` + +### 2. Password Requirements + +- Use a strong, unique password +- Avoid common passwords or dictionary words +- Consider using a password manager to generate and store the password +- The password is case-sensitive + +### 3. Restart Services + +After setting the password, restart all services: + +```bash +# If using make commands +make stop-all +make start-all + +# If using Docker +docker compose down +docker compose --profile multi up +``` + +## How It Works + +### Streamlit UI Protection + +- Users see a login form when accessing the application +- Password is stored in the browser session +- Users remain logged in until they close the browser or clear session data +- No logout button is provided - users can clear browser data to log out + +### API Protection + +- All API endpoints require the password in the Authorization header +- Format: `Authorization: Bearer your_password` +- Health check endpoint (`/health`) is excluded from authentication +- API documentation (`/docs`) is excluded from authentication + +### Example API Usage + +```bash +# Without password protection +curl http://localhost:5055/api/notebooks + +# With password protection +curl -H "Authorization: Bearer your_password" http://localhost:5055/api/notebooks +``` + +## Security Considerations + +### This is Basic Protection + +The password protection is designed for basic access control, not enterprise security: + +- Passwords are transmitted and stored in plain text +- No user roles or permissions system +- No session management or timeout +- No password complexity requirements +- No protection against brute force attacks + +### Production Recommendations + +For production deployments requiring robust security: + +1. **Use HTTPS**: Always deploy behind HTTPS/TLS +2. **Reverse Proxy**: Use nginx or similar with additional security headers +3. **Network Security**: Implement proper firewall rules +4. **Regular Updates**: Keep Open Notebook and dependencies updated +5. **Monitoring**: Log access attempts and monitor for suspicious activity + +## Troubleshooting + +### Common Issues + +**401 Unauthorized Errors:** +- Check that the password is set correctly in your environment +- Verify the Authorization header format: `Bearer your_password` +- Restart all services after setting the password + +**UI Not Showing Login Form:** +- Ensure the `OPEN_NOTEBOOK_PASSWORD` environment variable is set +- Check that the Streamlit service restarted properly +- Clear browser cache and cookies + +**API Calls Failing:** +- Verify the password is included in the Authorization header +- Check that the API service has access to the environment variable +- Test with a simple curl command first + +### Getting Help + +If you encounter issues with password protection: + +1. Check the application logs for error messages +2. Verify environment variables are set correctly +3. Test with a simple password first +4. Join our [Discord server](https://discord.gg/37XJPXfz2w) for community support +5. Report bugs on [GitHub Issues](https://github.com/lfnovo/open-notebook/issues) \ No newline at end of file diff --git a/docs/single-container-deployment.md b/docs/single-container-deployment.md new file mode 100644 index 0000000..d704e6d --- /dev/null +++ b/docs/single-container-deployment.md @@ -0,0 +1,195 @@ +# Single-Container Deployment Guide + +For users who prefer an all-in-one container solution (e.g., PikaPods, simple deployments), Open Notebook provides a single-container image that includes all services: SurrealDB, API backend, background worker, and Streamlit UI. + +## Overview + +The single-container deployment packages: +- **SurrealDB**: Database service +- **FastAPI**: REST API backend +- **Background Worker**: For podcast generation and transformations +- **Streamlit**: Web UI interface + +All services are managed by supervisord with proper startup ordering. + +## Quick Start + +### Option 1: Using Docker Compose (Recommended) + +1. Create a `docker-compose.single.yml` file: + +```yaml +services: + open_notebook_single: + image: lfnovo/open_notebook:latest-single + ports: + - "8502:8502" # Streamlit UI + - "5055:5055" # REST API + environment: + # Add your API keys here + - OPENAI_API_KEY=your_openai_key + - ANTHROPIC_API_KEY=your_anthropic_key + # ... other environment variables + volumes: + - ./notebook_data:/app/data # Application data + - ./surreal_single_data:/mydata # SurrealDB data + restart: always +``` + +2. Run the container: + +```bash +docker compose -f docker-compose.single.yml up -d +``` + +### Option 2: Direct Docker Run + +```bash +docker run -d \ + --name open-notebook-single \ + -p 8502:8502 \ + -p 5055:5055 \ + -v ./notebook_data:/app/data \ + -v ./surreal_single_data:/mydata \ + -e OPENAI_API_KEY=your_openai_key \ + -e ANTHROPIC_API_KEY=your_anthropic_key \ + lfnovo/open_notebook:latest-single +``` + +### Option 3: PikaPods Deployment + +For PikaPods users, use the single-container image: + +``` +Image: lfnovo/open_notebook:latest-single +Port: 8502 +``` + +Add your API keys as environment variables in the PikaPods configuration. + +## Environment Variables + +The single-container deployment uses the same environment variables as the multi-container setup, but with SurrealDB configured for localhost connection: + +```bash +# Database connection (automatically configured) +SURREAL_URL="ws://localhost:8000/rpc" +SURREAL_USER="root" +SURREAL_PASSWORD="root" +SURREAL_NAMESPACE="open_notebook" +SURREAL_DATABASE="staging" + +# API Keys (configure these) +OPENAI_API_KEY=your_openai_key +ANTHROPIC_API_KEY=your_anthropic_key +GEMINI_API_KEY=your_gemini_key +# ... other provider keys +``` + +## Service Access + +Once running, access the services at: + +- **Streamlit UI**: http://localhost:8502 +- **REST API**: http://localhost:5055 +- **API Documentation**: http://localhost:5055/docs + +## Data Persistence + +The single-container setup uses two volume mounts: + +1. `/app/data` - Application data (notebooks, sources, etc.) +2. `/mydata` - SurrealDB database files + +Make sure to mount these volumes to persist data between container restarts. + +## Security + +For public deployments, always set the `OPEN_NOTEBOOK_PASSWORD` environment variable: + +```bash +OPEN_NOTEBOOK_PASSWORD=your_secure_password +``` + +This protects both the Streamlit UI and REST API with password authentication. + +## Building from Source + +To build the single-container image yourself: + +```bash +# Clone the repository +git clone https://github.com/lfnovo/open-notebook +cd open-notebook + +# Build the single-container image +make docker-build-single-dev + +# Or build with multi-platform support +make docker-build-single +``` + +## Troubleshooting + +### Container Won't Start + +Check the logs to see which service is failing: + +```bash +docker logs open-notebook-single +``` + +### Database Connection Issues + +The single-container uses localhost for SurrealDB. If you see connection errors, ensure: + +1. The container has enough memory (minimum 1GB recommended) +2. No port conflicts on 8000 (SurrealDB internal port) +3. The `/mydata` volume is properly mounted and writable + +### Service Startup Order + +Services start in this order: +1. SurrealDB (5 seconds startup time) +2. API Backend (3 seconds startup time) +3. Background Worker (3 seconds startup time) +4. Streamlit UI (5 seconds startup time) + +If services fail to start, check the supervisord logs in the container. + +## Resource Requirements + +**Minimum Requirements:** +- Memory: 1GB RAM +- CPU: 1 core +- Storage: 10GB (for data persistence) + +**Recommended:** +- Memory: 2GB+ RAM +- CPU: 2+ cores +- Storage: 50GB+ (for larger datasets) + +## Differences from Multi-Container + +| Feature | Multi-Container | Single-Container | +|---------|-----------------|------------------| +| Database | Separate SurrealDB container | Built-in SurrealDB | +| Scaling | Can scale services independently | All services in one container | +| Resource Usage | More flexible resource allocation | Fixed resource sharing | +| Deployment | Requires docker-compose | Single container run | +| Complexity | More complex setup | Simpler deployment | +| Debugging | Easier to debug individual services | All logs in one container | + +## When to Use Single-Container + +**Use single-container when:** +- Deploying to platforms like PikaPods +- You want the simplest possible deployment +- Resource constraints favor single container +- You don't need to scale services independently + +**Use multi-container when:** +- You need fine-grained resource control +- You want to scale services independently +- You prefer traditional microservices architecture +- You need to debug individual services easily \ No newline at end of file diff --git a/migrations/7.surrealql b/migrations/7.surrealql new file mode 100644 index 0000000..b107908 --- /dev/null +++ b/migrations/7.surrealql @@ -0,0 +1,152 @@ +DEFINE TABLE IF NOT EXISTS episode_profile SCHEMAFULL; +DEFINE FIELD IF NOT EXISTS name ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS description ON TABLE episode_profile TYPE option; +DEFINE FIELD IF NOT EXISTS speaker_config ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS outline_provider ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS outline_model ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS transcript_provider ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS transcript_model ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS default_briefing ON TABLE episode_profile TYPE string; +DEFINE FIELD IF NOT EXISTS num_segments ON TABLE episode_profile TYPE int DEFAULT 5; +DEFINE FIELD IF NOT EXISTS created ON TABLE episode_profile TYPE datetime DEFAULT time::now(); +DEFINE FIELD IF NOT EXISTS updated ON TABLE episode_profile TYPE datetime DEFAULT time::now(); + +-- Create Speaker Profile table +remove table speaker_profile; +DEFINE TABLE IF NOT EXISTS speaker_profile SCHEMAFULL; +DEFINE FIELD IF NOT EXISTS name ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS description ON TABLE speaker_profile TYPE option; +DEFINE FIELD IF NOT EXISTS tts_provider ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS tts_model ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS speakers ON TABLE speaker_profile TYPE array; +DEFINE FIELD IF NOT EXISTS speakers.*.name ON TABLE speaker_profile TYPE string; +DEFINE FIELD IF NOT EXISTS speakers.*.voice_id ON TABLE speaker_profile TYPE option; +DEFINE FIELD IF NOT EXISTS speakers.*.backstory ON TABLE speaker_profile TYPE option; +DEFINE FIELD IF NOT EXISTS speakers.*.personality ON TABLE speaker_profile TYPE option; +DEFINE FIELD IF NOT EXISTS created ON TABLE speaker_profile TYPE datetime DEFAULT time::now(); +DEFINE FIELD IF NOT EXISTS updated ON TABLE speaker_profile TYPE datetime DEFAULT time::now(); + + +-- Enhance PodcastEpisode table +DEFINE TABLE IF NOT EXISTS episode SCHEMAFULL; +DEFINE FIELD IF NOT EXISTS created ON episode DEFAULT time::now() VALUE $before OR time::now(); +DEFINE FIELD IF NOT EXISTS updated ON episode DEFAULT time::now() VALUE time::now(); +DEFINE FIELD IF NOT EXISTS name ON TABLE episode TYPE string; +DEFINE FIELD IF NOT EXISTS briefing ON TABLE episode TYPE option; +DEFINE FIELD IF NOT EXISTS episode_profile ON TABLE episode FLEXIBLE TYPE object; +DEFINE FIELD IF NOT EXISTS speaker_profile ON TABLE episode FLEXIBLE TYPE object; +DEFINE FIELD IF NOT EXISTS transcript ON TABLE episode FLEXIBLE TYPE option; +DEFINE FIELD IF NOT EXISTS outline ON TABLE episode FLEXIBLE TYPE option; +DEFINE FIELD IF NOT EXISTS command ON TABLE episode TYPE option>; +DEFINE FIELD IF NOT EXISTS content ON TABLE episode TYPE option; +DEFINE FIELD IF NOT EXISTS audio_file ON TABLE episode TYPE option; + +-- Create indexes for better performance +DEFINE INDEX IF NOT EXISTS idx_episode_profile_name ON TABLE episode_profile COLUMNS name UNIQUE CONCURRENTLY; +DEFINE INDEX IF NOT EXISTS idx_speaker_profile_name ON TABLE speaker_profile COLUMNS name UNIQUE CONCURRENTLY; +DEFINE INDEX IF NOT EXISTS idx_episode_profile ON TABLE episode COLUMNS episode_profile CONCURRENTLY; +DEFINE INDEX IF NOT EXISTS idx_episode_command ON TABLE episode COLUMNS command CONCURRENTLY; + + +--Sample data + +insert into episode_profile +[ + { + name: "tech_discussion", + description: "Technical discussion between 2 experts", + speaker_config: "tech_experts", + outline_provider: "openai", + outline_model: "gpt-4o-mini", + transcript_provider: "openai", + transcript_model: "gpt-4o-mini", + default_briefing: "Create an engaging technical discussion about the provided content. Focus on practical insights, real-world applications, and detailed explanations that would interest developers and technical professionals.", + num_segments: 5 + }, + { + name: "solo_expert", + description: "Single expert explaining complex topics", + speaker_config: "solo_expert", + outline_provider: "openai", + outline_model: "gpt-4o-mini", + transcript_provider: "openai", + transcript_model: "gpt-4o-mini", + default_briefing: "Create an educational explanation of the provided content. Break down complex concepts into digestible segments, use analogies and examples, and maintain an engaging teaching style.", + "num_segments":4 }, + { + name: "business_analysis", + description: "Business-focused analysis and discussion", + speaker_config: "business_panel", + outline_provider: "openai", + outline_model: "gpt-4o-mini", + transcript_provider: "openai", + transcript_model: "gpt-4o-mini", + default_briefing: "Analyze the provided content from a business perspective. Discuss market implications, strategic insights, competitive advantages, and actionable business intelligence.", + "num_segments":6 } + ]; + +insert into speaker_profile +[ + { + name: "tech_experts", + description: "Two technical experts for tech discussions", + tts_provider: "openai", + tts_model: "tts-1", + speakers: [ + { + name: "Dr. Alex Chen", + voice_id: "nova", + backstory: "Senior AI researcher and former tech lead at major companies. Specializes in making complex technical concepts accessible.", + personality: "Analytical, clear communicator, asks probing questions to dig deeper into technical details" + }, + { + name: "Jamie Rodriguez", + voice_id: "alloy", + backstory: "Full-stack engineer and tech entrepreneur. Loves practical applications and real-world implementations.", + personality: "Enthusiastic, practical-minded, great at explaining implementation details and trade-offs" + } + ] + }, + { + name: "solo_expert", + description: "Single expert for educational content", + tts_provider: "openai", + tts_model: "tts-1", + speakers: [ + { + name: "Professor Sarah Kim", + voice_id: "nova", + backstory: "Distinguished professor and researcher. Has a gift for making complex topics accessible to broad audiences.", + personality: "Patient teacher, uses analogies and examples, breaks down complex concepts step by step" + } + ] + }, + { + name: "business_panel", + description: "Business analysis panel with diverse perspectives", + tts_provider: "openai", + tts_model: "tts-1", + speakers: [ + { + name: "Marcus Thompson", + voice_id: "echo", + backstory: "Former McKinsey consultant, now startup advisor. Expert in strategic analysis and market dynamics.", + personality: "Strategic thinker, data-driven, excellent at identifying key insights and implications" + }, + { + name: "Elena Vasquez", + voice_id: "shimmer", + backstory: "Serial entrepreneur and investor. Focuses on practical implementation and execution.", + personality: "Action-oriented, pragmatic, brings startup experience and execution focus" + }, + { + name: "Johny Bing", + voice_id: "ash", + backstory: "Youtube celebrity and business mogul. Focuses on practical implementation and execution.", + personality: "Controversial, likes to question ideas and concepts. He brings a fresh perspective and always has a point to make." + } + ] + } + ]; + + diff --git a/migrations/7_down.surrealql b/migrations/7_down.surrealql new file mode 100644 index 0000000..de41849 --- /dev/null +++ b/migrations/7_down.surrealql @@ -0,0 +1,3 @@ +REMOVE TABLE IF EXISTS episode_profile; +REMOVE TABLE IF EXISTS speaker_profile; +REMOVE TABLE IF EXISTS episode; diff --git a/open_notebook/config.py b/open_notebook/config.py index 450680a..721b94c 100644 --- a/open_notebook/config.py +++ b/open_notebook/config.py @@ -1,20 +1,5 @@ import os -import yaml -from loguru import logger - -current_dir = os.path.dirname(os.path.abspath(__file__)) -project_root = os.path.dirname(current_dir) -config_path = os.path.join(project_root, "open_notebook_config.yaml") - -try: - with open(config_path, "r") as file: - CONFIG = yaml.safe_load(file) -except Exception: - logger.critical("Config file not found, using empty defaults") - logger.debug(f"Looked in {config_path}") - CONFIG = {} - # ROOT DATA FOLDER DATA_FOLDER = "./data" diff --git a/open_notebook/database/async_migrate.py b/open_notebook/database/async_migrate.py new file mode 100644 index 0000000..fe8961e --- /dev/null +++ b/open_notebook/database/async_migrate.py @@ -0,0 +1,184 @@ +""" +Async migration system for SurrealDB using the official Python client. +Based on patterns from sblpy migration system. +""" + +from typing import List + +from loguru import logger + +from .repository import db_connection, repo_query + + +class AsyncMigration: + """ + Handles individual migration operations with async support. + """ + + def __init__(self, sql: str) -> None: + """Initialize migration with SQL content.""" + self.sql = sql + + @classmethod + def from_file(cls, file_path: str) -> "AsyncMigration": + """Create migration from SQL file.""" + with open(file_path, "r") as file: + raw_content = file.read() + # Clean up SQL content + lines = [] + for line in raw_content.split("\n"): + line = line.strip() + if line and not line.startswith("--"): + lines.append(line) + sql = " ".join(lines) + return cls(sql) + + async def run(self, bump: bool = True) -> None: + """Run the migration.""" + try: + async with db_connection() as connection: + await connection.query(self.sql) + + if bump: + await bump_version() + else: + await lower_version() + + except Exception as e: + logger.error(f"Migration failed: {str(e)}") + raise + + +class AsyncMigrationRunner: + """ + Handles running multiple migrations in sequence. + """ + + def __init__( + self, + up_migrations: List[AsyncMigration], + down_migrations: List[AsyncMigration], + ) -> None: + """Initialize runner with migration lists.""" + self.up_migrations = up_migrations + self.down_migrations = down_migrations + + async def run_all(self) -> None: + """Run all pending up migrations.""" + current_version = await get_latest_version() + + for i in range(current_version, len(self.up_migrations)): + logger.info(f"Running migration {i + 1}") + await self.up_migrations[i].run(bump=True) + + async def run_one_up(self) -> None: + """Run one up migration.""" + current_version = await get_latest_version() + + if current_version < len(self.up_migrations): + logger.info(f"Running migration {current_version + 1}") + await self.up_migrations[current_version].run(bump=True) + + async def run_one_down(self) -> None: + """Run one down migration.""" + current_version = await get_latest_version() + + if current_version > 0: + logger.info(f"Rolling back migration {current_version}") + await self.down_migrations[current_version - 1].run(bump=False) + + +class AsyncMigrationManager: + """ + Main migration manager with async support. + """ + + def __init__(self): + """Initialize migration manager.""" + self.up_migrations = [ + AsyncMigration.from_file("migrations/1.surrealql"), + AsyncMigration.from_file("migrations/2.surrealql"), + AsyncMigration.from_file("migrations/3.surrealql"), + AsyncMigration.from_file("migrations/4.surrealql"), + AsyncMigration.from_file("migrations/5.surrealql"), + AsyncMigration.from_file("migrations/6.surrealql"), + AsyncMigration.from_file("migrations/7.surrealql"), + ] + self.down_migrations = [ + AsyncMigration.from_file("migrations/1_down.surrealql"), + AsyncMigration.from_file("migrations/2_down.surrealql"), + AsyncMigration.from_file("migrations/3_down.surrealql"), + AsyncMigration.from_file("migrations/4_down.surrealql"), + AsyncMigration.from_file("migrations/5_down.surrealql"), + AsyncMigration.from_file("migrations/6_down.surrealql"), + AsyncMigration.from_file("migrations/7_down.surrealql"), + ] + self.runner = AsyncMigrationRunner( + up_migrations=self.up_migrations, + down_migrations=self.down_migrations, + ) + + async def get_current_version(self) -> int: + """Get current database version.""" + return await get_latest_version() + + async def needs_migration(self) -> bool: + """Check if migration is needed.""" + current_version = await self.get_current_version() + return current_version < len(self.up_migrations) + + async def run_migration_up(self): + """Run all pending migrations.""" + current_version = await self.get_current_version() + logger.info(f"Current version before migration: {current_version}") + + if await self.needs_migration(): + try: + await self.runner.run_all() + new_version = await self.get_current_version() + logger.info(f"Migration successful. New version: {new_version}") + except Exception as e: + logger.error(f"Migration failed: {str(e)}") + raise + else: + logger.info("Database is already at the latest version") + + +# Database version management functions +async def get_latest_version() -> int: + """Get the latest version from the migrations table.""" + try: + versions = await get_all_versions() + if not versions: + return 0 + return max(version["version"] for version in versions) + except Exception: + # If migrations table doesn't exist, we're at version 0 + return 0 + + +async def get_all_versions() -> List[dict]: + """Get all versions from the migrations table.""" + try: + result = await repo_query("SELECT * FROM _sbl_migrations ORDER BY version;") + return result + except Exception: + # If table doesn't exist, return empty list + return [] + + +async def bump_version() -> None: + """Bump the version by adding a new entry to migrations table.""" + current_version = await get_latest_version() + new_version = current_version + 1 + + await repo_query( + f"CREATE _sbl_migrations:{new_version} SET version = {new_version}, applied_at = time::now();", + ) + + +async def lower_version() -> None: + """Lower the version by removing the latest entry from migrations table.""" + current_version = await get_latest_version() + if current_version > 0: + await repo_query(f"DELETE _sbl_migrations:{current_version};") diff --git a/open_notebook/database/migrate.py b/open_notebook/database/migrate.py index 1c707fc..7573ba0 100644 --- a/open_notebook/database/migrate.py +++ b/open_notebook/database/migrate.py @@ -1,72 +1,26 @@ -import os +import asyncio -from loguru import logger -from sblpy.connection import SurrealSyncConnection -from sblpy.migrations.db_processes import get_latest_version -from sblpy.migrations.migrations import Migration -from sblpy.migrations.runner import MigrationRunner +from .async_migrate import AsyncMigrationManager class MigrationManager: + """ + Synchronous wrapper around AsyncMigrationManager for backward compatibility. + """ + def __init__(self): - self.connection = SurrealSyncConnection( - host=os.environ["SURREAL_ADDRESS"], - port=int(os.environ["SURREAL_PORT"]), - user=os.environ["SURREAL_USER"], - password=os.environ["SURREAL_PASS"], - namespace=os.environ["SURREAL_NAMESPACE"], - database=os.environ["SURREAL_DATABASE"], - encrypted=False, # Set to True if using SSL - ) - self.up_migrations = [ - Migration.from_file("migrations/1.surrealql"), - Migration.from_file("migrations/2.surrealql"), - Migration.from_file("migrations/3.surrealql"), - Migration.from_file("migrations/4.surrealql"), - Migration.from_file("migrations/5.surrealql"), - Migration.from_file("migrations/6.surrealql"), - ] - self.down_migrations = [ - Migration.from_file( - "migrations/1_down.surrealql", - ), - Migration.from_file("migrations/2_down.surrealql"), - Migration.from_file("migrations/3_down.surrealql"), - Migration.from_file("migrations/4_down.surrealql"), - Migration.from_file("migrations/5_down.surrealql"), - Migration.from_file("migrations/6_down.surrealql"), - ] - self.runner = MigrationRunner( - up_migrations=self.up_migrations, - down_migrations=self.down_migrations, - connection=self.connection, - ) + """Initialize with async migration manager.""" + self._async_manager = AsyncMigrationManager() def get_current_version(self) -> int: - return get_latest_version( - self.connection.host, - self.connection.port, - self.connection.user, - self.connection.password, - self.connection.namespace, - self.connection.database, - ) + """Get current database version (sync wrapper).""" + return asyncio.run(self._async_manager.get_current_version()) @property def needs_migration(self) -> bool: - current_version = self.get_current_version() - return current_version < len(self.up_migrations) + """Check if migration is needed (sync wrapper).""" + return asyncio.run(self._async_manager.needs_migration()) def run_migration_up(self): - current_version = self.get_current_version() - logger.info(f"Current version before migration: {current_version}") - - if self.needs_migration: - try: - self.runner.run() - new_version = self.get_current_version() - logger.info(f"Migration successful. New version: {new_version}") - except Exception as e: - logger.error(f"Migration failed: {str(e)}") - else: - logger.info("Database is already at the latest version") + """Run migrations (sync wrapper).""" + asyncio.run(self._async_manager.run_migration_up()) diff --git a/open_notebook/database/new.py b/open_notebook/database/new.py new file mode 100644 index 0000000..bf5843f --- /dev/null +++ b/open_notebook/database/new.py @@ -0,0 +1,178 @@ +import os +from contextlib import asynccontextmanager +from datetime import datetime, timezone +from typing import Any, Dict, List, Optional, TypeVar, Union + +from loguru import logger +from surrealdb import AsyncSurreal, RecordID # type: ignore + +T = TypeVar("T", Dict[str, Any], List[Dict[str, Any]]) + + +def get_database_url(): + """Get database URL with backward compatibility""" + surreal_url = os.getenv("SURREAL_URL") + if surreal_url: + return surreal_url + + # Fallback to old format - WebSocket URL format + address = os.getenv("SURREAL_ADDRESS", "localhost") + port = os.getenv("SURREAL_PORT", "8000") + return f"ws://{address}/rpc:{port}" + + +def get_database_password(): + """Get password with backward compatibility""" + return os.getenv("SURREAL_PASSWORD") or os.getenv("SURREAL_PASS") + + +def parse_record_ids(obj: Any) -> Any: + """Recursively parse and convert RecordIDs into strings.""" + if isinstance(obj, dict): + return {k: parse_record_ids(v) for k, v in obj.items()} + elif isinstance(obj, list): + return [parse_record_ids(item) for item in obj] + elif isinstance(obj, RecordID): + return str(obj) + return obj + + +def ensure_record_id(value: Union[str, RecordID]) -> RecordID: + """Ensure a value is a RecordID.""" + if isinstance(value, RecordID): + return value + return RecordID.parse(value) + + +@asynccontextmanager +async def db_connection(): + db = AsyncSurreal(get_database_url()) + await db.signin( + { + "username": os.environ["SURREAL_USER"], + "password": get_database_password(), + } + ) + await db.use(os.environ["SURREAL_NAMESPACE"], os.environ["SURREAL_DATABASE"]) + try: + yield db + finally: + await db.close() + + +async def repo_query( + query_str: str, vars: Optional[Dict[str, Any]] = None +) -> List[Dict[str, Any]]: + """Execute a SurrealQL query and return the results""" + + async with db_connection() as connection: + try: + result = parse_record_ids(await connection.query(query_str, vars)) + if isinstance(result, str): + raise RuntimeError(result) + return result + except Exception as e: + logger.error(f"Query: {query_str[:200]} vars: {vars}") + logger.exception(e) + raise + + +async def repo_create(table: str, data: Dict[str, Any]) -> Dict[str, Any]: + """Create a new record in the specified table""" + # Remove 'id' attribute if it exists in data + data.pop("id", None) + data["created"] = datetime.now(timezone.utc) + data["updated"] = datetime.now(timezone.utc) + try: + async with db_connection() as connection: + return parse_record_ids(await connection.insert(table, data)) + except Exception as e: + logger.exception(e) + raise RuntimeError("Failed to create record") + + +async def repo_relate( + source: str, relationship: str, target: str, data: Optional[Dict[str, Any]] = None +) -> List[Dict[str, Any]]: + """Create a relationship between two records with optional data""" + if data is None: + data = {} + query = f"RELATE {source}->{relationship}->{target} CONTENT $data;" + # logger.debug(f"Relate query: {query}") + + return await repo_query( + query, + { + "data": data, + }, + ) + + +async def repo_upsert( + table: str, id: Optional[str], data: Dict[str, Any], add_timestamp: bool = False +) -> List[Dict[str, Any]]: + """Create or update a record in the specified table""" + data.pop("id", None) + if add_timestamp: + data["updated"] = datetime.now(timezone.utc) + query = f"UPSERT {id if id else table} MERGE $data;" + return await repo_query(query, {"data": data}) + + +async def repo_update( + table: str, id: str, data: Dict[str, Any] +) -> List[Dict[str, Any]]: + """Update an existing record by table and id""" + # If id already contains the table name, use it as is + try: + if isinstance(id, RecordID) or (":" in id and id.startswith(f"{table}:")): + record_id = id + else: + record_id = f"{table}:{id}" + + data["updated"] = datetime.now(timezone.utc) + query = f"UPDATE {record_id} MERGE $data;" + # logger.debug(f"Update query: {query}") + result = await repo_query(query, {"data": data}) + # if isinstance(result, list): + # return [_return_data(item) for item in result] + return [parse_record_ids(result)] + except Exception as e: + raise RuntimeError(f"Failed to update record: {str(e)}") + + +async def repo_get_news_by_jota_id(jota_id: str) -> Dict[str, Any]: + try: + results = await repo_query( + "SELECT * omit embedding FROM news where jota_id=$jota_id", + {"jota_id": jota_id}, + ) + return parse_record_ids(results) + except Exception as e: + logger.exception(e) + raise RuntimeError(f"Failed to fetch record: {str(e)}") + + +async def repo_delete(record_id: Union[str, RecordID]): + """Delete a record by record id""" + + try: + async with db_connection() as connection: + return await connection.delete(record_id) + except Exception as e: + logger.exception(e) + raise RuntimeError(f"Failed to delete record: {str(e)}") + + +async def repo_insert( + table: str, data: List[Dict[str, Any]], ignore_duplicates: bool = False +) -> List[Dict[str, Any]]: + """Create a new record in the specified table""" + try: + async with db_connection() as connection: + return parse_record_ids(await connection.insert(table, data)) + except Exception as e: + if ignore_duplicates and "already contains" in str(e): + return [] + logger.exception(e) + raise RuntimeError("Failed to create record") diff --git a/open_notebook/database/repository.py b/open_notebook/database/repository.py index d90ac9d..c29570d 100644 --- a/open_notebook/database/repository.py +++ b/open_notebook/database/repository.py @@ -1,63 +1,180 @@ import os -from contextlib import contextmanager -from typing import Any, Dict, Optional +from contextlib import asynccontextmanager +from datetime import datetime, timezone +from typing import Any, Dict, List, Optional, TypeVar, Union from loguru import logger -from sblpy.connection import SurrealSyncConnection +from surrealdb import AsyncSurreal, RecordID # type: ignore + +T = TypeVar("T", Dict[str, Any], List[Dict[str, Any]]) -@contextmanager -def db_connection(): - connection = SurrealSyncConnection( - host=os.environ["SURREAL_ADDRESS"], - port=int(os.environ["SURREAL_PORT"]), - user=os.environ["SURREAL_USER"], - password=os.environ["SURREAL_PASS"], - namespace=os.environ["SURREAL_NAMESPACE"], - database=os.environ["SURREAL_DATABASE"], - max_size=2.2**20, - encrypted=False, # Set to True if using SSL +def get_database_url(): + """Get database URL with backward compatibility""" + surreal_url = os.getenv("SURREAL_URL") + if surreal_url: + return surreal_url + + # Fallback to old format - WebSocket URL format + address = os.getenv("SURREAL_ADDRESS", "localhost") + port = os.getenv("SURREAL_PORT", "8000") + return f"ws://{address}/rpc:{port}" + + +def get_database_password(): + """Get password with backward compatibility""" + return os.getenv("SURREAL_PASSWORD") or os.getenv("SURREAL_PASS") + + +def parse_record_ids(obj: Any) -> Any: + """Recursively parse and convert RecordIDs into strings.""" + if isinstance(obj, dict): + return {k: parse_record_ids(v) for k, v in obj.items()} + elif isinstance(obj, list): + return [parse_record_ids(item) for item in obj] + elif isinstance(obj, RecordID): + return str(obj) + return obj + + +def ensure_record_id(value: Union[str, RecordID]) -> RecordID: + """Ensure a value is a RecordID.""" + if isinstance(value, RecordID): + return value + return RecordID.parse(value) + + +@asynccontextmanager +async def db_connection(): + db = AsyncSurreal(get_database_url()) + await db.signin( + { + "username": os.environ["SURREAL_USER"], + "password": get_database_password(), + } ) + await db.use(os.environ["SURREAL_NAMESPACE"], os.environ["SURREAL_DATABASE"]) try: - yield connection + yield db finally: - connection.socket.close() + await db.close() -def repo_query(query_str: str, vars: Optional[Dict[str, Any]] = None): - with db_connection() as connection: +async def repo_query( + query_str: str, vars: Optional[Dict[str, Any]] = None +) -> List[Dict[str, Any]]: + """Execute a SurrealQL query and return the results""" + + async with db_connection() as connection: try: - result = connection.query(query_str, vars) + result = parse_record_ids(await connection.query(query_str, vars)) + if isinstance(result, str): + raise RuntimeError(result) return result except Exception as e: - logger.critical(f"Query: {query_str}") + logger.error(f"Query: {query_str[:200]} vars: {vars}") logger.exception(e) raise -def repo_create(table: str, data: Dict[str, Any]): - query = f"CREATE {table} CONTENT {data};" - return repo_query(query) +async def repo_create(table: str, data: Dict[str, Any]) -> Dict[str, Any]: + """Create a new record in the specified table""" + # Remove 'id' attribute if it exists in data + data.pop("id", None) + data["created"] = datetime.now(timezone.utc) + data["updated"] = datetime.now(timezone.utc) + try: + async with db_connection() as connection: + return parse_record_ids(await connection.insert(table, data)) + except Exception as e: + logger.exception(e) + raise RuntimeError("Failed to create record") -def repo_upsert(table: str, data: Dict[str, Any]): - query = f"UPSERT {table} CONTENT {data};" - return repo_query(query) +async def repo_relate( + source: str, relationship: str, target: str, data: Optional[Dict[str, Any]] = None +) -> List[Dict[str, Any]]: + """Create a relationship between two records with optional data""" + if data is None: + data = {} + query = f"RELATE {source}->{relationship}->{target} CONTENT $data;" + # logger.debug(f"Relate query: {query}") + + return await repo_query( + query, + { + "data": data, + }, + ) -def repo_update(id: str, data: Dict[str, Any]): - query = "UPDATE $id CONTENT $data;" - vars = {"id": id, "data": data} - return repo_query(query, vars) +async def repo_upsert( + table: str, id: Optional[str], data: Dict[str, Any], add_timestamp: bool = False +) -> List[Dict[str, Any]]: + """Create or update a record in the specified table""" + data.pop("id", None) + if add_timestamp: + data["updated"] = datetime.now(timezone.utc) + query = f"UPSERT {id if id else table} MERGE $data;" + return await repo_query(query, {"data": data}) -def repo_delete(id: str): - query = "DELETE $id;" - vars = {"id": id} - return repo_query(query, vars) +async def repo_update( + table: str, id: str, data: Dict[str, Any] +) -> List[Dict[str, Any]]: + """Update an existing record by table and id""" + # If id already contains the table name, use it as is + try: + if isinstance(id, RecordID) or (":" in id and id.startswith(f"{table}:")): + record_id = id + else: + record_id = f"{table}:{id}" + data.pop("id", None) + if "created" in data and isinstance(data["created"], str): + data["created"] = datetime.fromisoformat(data["created"]) + data["updated"] = datetime.now(timezone.utc) + query = f"UPDATE {record_id} MERGE $data;" + # logger.debug(f"Update query: {query}") + result = await repo_query(query, {"data": data}) + # if isinstance(result, list): + # return [_return_data(item) for item in result] + return parse_record_ids(result) + except Exception as e: + raise RuntimeError(f"Failed to update record: {str(e)}") -def repo_relate(source: str, relationship: str, target: str, data: Optional[Dict] = {}): - query = f"RELATE {source}->{relationship}->{target} CONTENT $content;" - result = repo_query(query, {"content": data}) - return result +async def repo_get_news_by_jota_id(jota_id: str) -> Dict[str, Any]: + try: + results = await repo_query( + "SELECT * omit embedding FROM news where jota_id=$jota_id", + {"jota_id": jota_id}, + ) + return parse_record_ids(results) + except Exception as e: + logger.exception(e) + raise RuntimeError(f"Failed to fetch record: {str(e)}") + + +async def repo_delete(record_id: Union[str, RecordID]): + """Delete a record by record id""" + + try: + async with db_connection() as connection: + return await connection.delete(ensure_record_id(record_id)) + except Exception as e: + logger.exception(e) + raise RuntimeError(f"Failed to delete record: {str(e)}") + + +async def repo_insert( + table: str, data: List[Dict[str, Any]], ignore_duplicates: bool = False +) -> List[Dict[str, Any]]: + """Create a new record in the specified table""" + try: + async with db_connection() as connection: + return parse_record_ids(await connection.insert(table, data)) + except Exception as e: + if ignore_duplicates and "already contains" in str(e): + return [] + logger.exception(e) + raise RuntimeError("Failed to create record") diff --git a/open_notebook/database/repository_old.py b/open_notebook/database/repository_old.py new file mode 100644 index 0000000..d90ac9d --- /dev/null +++ b/open_notebook/database/repository_old.py @@ -0,0 +1,63 @@ +import os +from contextlib import contextmanager +from typing import Any, Dict, Optional + +from loguru import logger +from sblpy.connection import SurrealSyncConnection + + +@contextmanager +def db_connection(): + connection = SurrealSyncConnection( + host=os.environ["SURREAL_ADDRESS"], + port=int(os.environ["SURREAL_PORT"]), + user=os.environ["SURREAL_USER"], + password=os.environ["SURREAL_PASS"], + namespace=os.environ["SURREAL_NAMESPACE"], + database=os.environ["SURREAL_DATABASE"], + max_size=2.2**20, + encrypted=False, # Set to True if using SSL + ) + try: + yield connection + finally: + connection.socket.close() + + +def repo_query(query_str: str, vars: Optional[Dict[str, Any]] = None): + with db_connection() as connection: + try: + result = connection.query(query_str, vars) + return result + except Exception as e: + logger.critical(f"Query: {query_str}") + logger.exception(e) + raise + + +def repo_create(table: str, data: Dict[str, Any]): + query = f"CREATE {table} CONTENT {data};" + return repo_query(query) + + +def repo_upsert(table: str, data: Dict[str, Any]): + query = f"UPSERT {table} CONTENT {data};" + return repo_query(query) + + +def repo_update(id: str, data: Dict[str, Any]): + query = "UPDATE $id CONTENT $data;" + vars = {"id": id, "data": data} + return repo_query(query, vars) + + +def repo_delete(id: str): + query = "DELETE $id;" + vars = {"id": id} + return repo_query(query, vars) + + +def repo_relate(source: str, relationship: str, target: str, data: Optional[Dict] = {}): + query = f"RELATE {source}->{relationship}->{target} CONTENT $content;" + result = repo_query(query, {"content": data}) + return result diff --git a/open_notebook/domain/base.py b/open_notebook/domain/base.py index eb4f000..6ff8328 100644 --- a/open_notebook/domain/base.py +++ b/open_notebook/domain/base.py @@ -5,6 +5,7 @@ from loguru import logger from pydantic import BaseModel, ValidationError, field_validator, model_validator from open_notebook.database.repository import ( + ensure_record_id, repo_create, repo_delete, repo_query, @@ -28,7 +29,7 @@ class ObjectModel(BaseModel): updated: Optional[datetime] = None @classmethod - def get_all(cls: Type[T], order_by=None) -> List[T]: + async def get_all(cls: Type[T], order_by=None) -> List[T]: try: # If called from a specific subclass, use its table_name if cls.table_name: @@ -39,13 +40,12 @@ class ObjectModel(BaseModel): raise InvalidInputError( "get_all() must be called from a specific model class" ) - if order_by: - order = f" ORDER BY {order_by}" + query = f"SELECT * FROM {table_name} ORDER BY {order_by}" else: - order = "" + query = f"SELECT * FROM {table_name}" - result = repo_query(f"SELECT * FROM {table_name} {order}") + result = await repo_query(query) objects = [] for obj in result: try: @@ -60,7 +60,7 @@ class ObjectModel(BaseModel): raise DatabaseOperationError(e) @classmethod - def get(cls: Type[T], id: str) -> T: + async def get(cls: Type[T], id: str) -> T: if not id: raise InvalidInputError("ID cannot be empty") try: @@ -77,7 +77,7 @@ class ObjectModel(BaseModel): raise InvalidInputError(f"No class found for table {table_name}") target_class = cast(Type[T], found_class) - result = repo_query(f"SELECT * FROM {id}") + result = await repo_query("SELECT * FROM $id", {"id": ensure_record_id(id)}) if result: return target_class(**result[0]) else: @@ -109,7 +109,7 @@ class ObjectModel(BaseModel): def get_embedding_content(self) -> Optional[str]: return None - def save(self) -> None: + async def save(self) -> None: from open_notebook.domain.models import model_manager try: @@ -120,20 +120,20 @@ class ObjectModel(BaseModel): if self.needs_embedding(): embedding_content = self.get_embedding_content() if embedding_content: - EMBEDDING_MODEL = model_manager.embedding_model + EMBEDDING_MODEL = await model_manager.get_embedding_model() if not EMBEDDING_MODEL: logger.warning( "No embedding model found. Content will not be searchable." ) data["embedding"] = ( - EMBEDDING_MODEL.embed([embedding_content])[0] + (await EMBEDDING_MODEL.aembed([embedding_content]))[0] if EMBEDDING_MODEL else [] ) if self.id is None: data["created"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - repo_result = repo_create(self.__class__.table_name, data) + repo_result = await repo_create(self.__class__.table_name, data) else: data["created"] = ( self.created.strftime("%Y-%m-%d %H:%M:%S") @@ -141,8 +141,9 @@ class ObjectModel(BaseModel): else self.created ) logger.debug(f"Updating record with id {self.id}") - repo_result = repo_update(self.id, data) - + repo_result = await repo_update( + self.__class__.table_name, self.id, data + ) # Update the current instance with the result for key, value in repo_result[0].items(): if hasattr(self, key): @@ -156,23 +157,18 @@ class ObjectModel(BaseModel): raise except Exception as e: logger.error(f"Error saving record: {e}") - raise - - except Exception as e: - logger.error(f"Error saving {self.__class__.table_name}: {str(e)}") - logger.exception(e) raise DatabaseOperationError(e) def _prepare_save_data(self) -> Dict[str, Any]: data = self.model_dump() return {key: value for key, value in data.items() if value is not None} - def delete(self) -> bool: + async def delete(self) -> bool: if self.id is None: raise InvalidInputError("Cannot delete object without an ID") try: logger.debug(f"Deleting record with id {self.id}") - return repo_delete(self.id) + return await repo_delete(self.id) except Exception as e: logger.error( f"Error deleting {self.__class__.table_name} with id {self.id}: {str(e)}" @@ -181,13 +177,13 @@ class ObjectModel(BaseModel): f"Failed to delete {self.__class__.table_name}" ) - def relate( + async def relate( self, relationship: str, target_id: str, data: Optional[Dict] = {} ) -> Any: if not relationship or not target_id or not self.id: raise InvalidInputError("Relationship and target ID must be provided") try: - return repo_relate( + return await repo_relate( source=self.id, relationship=relationship, target=target_id, data=data ) except Exception as e: @@ -236,36 +232,57 @@ class RecordModel(BaseModel): # Only initialize if this is a new instance if not hasattr(self, "_initialized"): object.__setattr__(self, "__dict__", {}) - # Load data from DB first - result = repo_query(f"SELECT * FROM {self.record_id};") - # Initialize with DB data and any overrides - init_data = {} - if result and result[0]: - init_data.update(result[0]) + # For RecordModel, we need to handle async initialization differently + # Initialize with provided kwargs only for now + super().__init__(**kwargs) - # Override with any provided kwargs - if kwargs: - init_data.update(kwargs) - - # Initialize base model first - super().__init__(**init_data) - - # Mark as initialized + # Mark as initialized but not loaded from DB yet object.__setattr__(self, "_initialized", True) + object.__setattr__(self, "_db_loaded", False) + + async def _load_from_db(self): + """Load data from database if not already loaded""" + if not getattr(self, "_db_loaded", False): + result = await repo_query( + "SELECT * FROM ONLY $record_id", + {"record_id": ensure_record_id(self.record_id)}, + ) + + # Handle case where record doesn't exist yet + if result: + if isinstance(result, list) and len(result) > 0: + # Standard list response + row = result[0] + if isinstance(row, dict): + for key, value in row.items(): + if hasattr(self, key): + object.__setattr__(self, key, value) + elif isinstance(result, dict): + # Direct dict response + for key, value in result.items(): + if hasattr(self, key): + object.__setattr__(self, key, value) + + object.__setattr__(self, "_db_loaded", True) @classmethod - def get_instance(cls) -> "RecordModel": - """Get or create the singleton instance""" - return cls() + async def get_instance(cls) -> "RecordModel": + """Get or create the singleton instance and load from DB""" + instance = cls() + await instance._load_from_db() + return instance @model_validator(mode="after") def auto_save_validator(self): if self.__class__.auto_save: - self.update() + # Auto-save can't work with async - log warning + logger.warning( + f"Auto-save is enabled for {self.__class__.__name__} but update() is now async. Call await instance.update() manually." + ) return self - def update(self): + async def update(self): # Get all non-ClassVar fields and their values data = { field_name: getattr(self, field_name) @@ -273,9 +290,17 @@ class RecordModel(BaseModel): if not str(field_info.annotation).startswith("typing.ClassVar") } - repo_upsert(self.record_id, data) + await repo_upsert( + self.__class__.table_name + if hasattr(self.__class__, "table_name") + else "record", + self.record_id, + data, + ) - result = repo_query(f"SELECT * FROM {self.record_id};") + result = await repo_query( + "SELECT * FROM $record_id", {"record_id": ensure_record_id(self.record_id)} + ) if result: for key, value in result[0].items(): if hasattr(self, key): @@ -291,8 +316,8 @@ class RecordModel(BaseModel): if cls.record_id in cls._instances: del cls._instances[cls.record_id] - def patch(self, model_dict: dict): + async def patch(self, model_dict: dict): """Update model attributes from dictionary and save""" for key, value in model_dict.items(): setattr(self, key, value) - self.update() + await self.update() diff --git a/open_notebook/domain/content_settings.py b/open_notebook/domain/content_settings.py index 1a5bde5..bb79f89 100644 --- a/open_notebook/domain/content_settings.py +++ b/open_notebook/domain/content_settings.py @@ -1,4 +1,4 @@ -from typing import ClassVar, Literal, Optional +from typing import ClassVar, List, Literal, Optional from pydantic import Field @@ -19,3 +19,7 @@ class ContentSettings(RecordModel): auto_delete_files: Optional[Literal["yes", "no"]] = Field( "yes", description="Auto Delete Uploaded Files" ) + youtube_preferred_languages: Optional[List[str]] = Field( + ["en", "pt", "es", "de", "nl", "en-GB", "fr", "de", "hi", "ja"], + description="Preferred languages for YouTube transcripts", + ) diff --git a/open_notebook/domain/models.py b/open_notebook/domain/models.py index f47fb1a..22e07c3 100644 --- a/open_notebook/domain/models.py +++ b/open_notebook/domain/models.py @@ -21,8 +21,8 @@ class Model(ObjectModel): type: str @classmethod - def get_models_by_type(cls, model_type): - models = repo_query( + async def get_models_by_type(cls, model_type): + models = await repo_query( "SELECT * FROM model WHERE type=$model_type;", {"model_type": model_type} ) return [Model(**model) for model in models] @@ -53,9 +53,8 @@ class ModelManager: self._initialized = True self._model_cache: Dict[str, ModelType] = {} self._default_models = None - self.refresh_defaults() - def get_model(self, model_id: str, **kwargs) -> Optional[ModelType]: + async def get_model(self, model_id: str, **kwargs) -> Optional[ModelType]: if not model_id: return None @@ -72,9 +71,9 @@ class ModelManager: ) return cached_model - model: Model = Model.get(model_id) - - if not model: + try: + model: Model = await Model.get(model_id) + except Exception: raise ValueError(f"Model with ID {model_id} not found") if not model.type or model.type not in [ @@ -85,84 +84,86 @@ class ModelManager: ]: raise ValueError(f"Invalid model type: {model.type}") + model_instance: ModelType if model.type == "language": - model_instance: LanguageModel = AIFactory.create_language( + model_instance = AIFactory.create_language( model_name=model.name, provider=model.provider, config=kwargs, ) elif model.type == "embedding": - model_instance: EmbeddingModel = AIFactory.create_embedding( + model_instance = AIFactory.create_embedding( model_name=model.name, provider=model.provider, config=kwargs, ) elif model.type == "speech_to_text": - model_instance: SpeechToTextModel = AIFactory.create_speech_to_text( + model_instance = AIFactory.create_speech_to_text( model_name=model.name, provider=model.provider, config=kwargs, ) elif model.type == "text_to_speech": - model_instance: TextToSpeechModel = AIFactory.create_text_to_speech( + model_instance = AIFactory.create_text_to_speech( model_name=model.name, provider=model.provider, config=kwargs, ) + else: + raise ValueError(f"Invalid model type: {model.type}") self._model_cache[cache_key] = model_instance return model_instance - def refresh_defaults(self): + async def refresh_defaults(self): """Refresh the default models from the database""" - self._default_models = DefaultModels() + self._default_models = await DefaultModels.get_instance() - @property - def defaults(self) -> DefaultModels: + async def get_defaults(self) -> DefaultModels: """Get the default models configuration""" if not self._default_models: - self.refresh_defaults() + await self.refresh_defaults() if not self._default_models: raise RuntimeError("Failed to initialize default models configuration") return self._default_models - @property - def speech_to_text(self, **kwargs) -> Optional[SpeechToTextModel]: + async def get_speech_to_text(self, **kwargs) -> Optional[SpeechToTextModel]: """Get the default speech-to-text model""" - model_id = self.defaults.default_speech_to_text_model + defaults = await self.get_defaults() + model_id = defaults.default_speech_to_text_model if not model_id: return None - model = self.get_model(model_id, **kwargs) + model = await self.get_model(model_id, **kwargs) assert model is None or isinstance(model, SpeechToTextModel), ( f"Expected SpeechToTextModel but got {type(model)}" ) return model - @property - def text_to_speech(self, **kwargs) -> Optional[TextToSpeechModel]: + async def get_text_to_speech(self, **kwargs) -> Optional[TextToSpeechModel]: """Get the default text-to-speech model""" - model_id = self.defaults.default_text_to_speech_model + defaults = await self.get_defaults() + model_id = defaults.default_text_to_speech_model if not model_id: return None - model = self.get_model(model_id, **kwargs) + model = await self.get_model(model_id, **kwargs) assert model is None or isinstance(model, TextToSpeechModel), ( f"Expected TextToSpeechModel but got {type(model)}" ) return model - @property - def embedding_model(self, **kwargs) -> Optional[EmbeddingModel]: + async def get_embedding_model(self, **kwargs) -> Optional[EmbeddingModel]: """Get the default embedding model""" - model_id = self.defaults.default_embedding_model + defaults = await self.get_defaults() + model_id = defaults.default_embedding_model if not model_id: return None - model = self.get_model(model_id, **kwargs) + model = await self.get_model(model_id, **kwargs) assert model is None or isinstance(model, EmbeddingModel), ( f"Expected EmbeddingModel but got {type(model)}" ) return model - def get_default_model(self, model_type: str, **kwargs) -> Optional[ModelType]: + async def get_default_model(self, model_type: str, **kwargs) -> Optional[ModelType]: """ Get the default model for a specific type. @@ -170,32 +171,33 @@ class ModelManager: model_type: The type of model to retrieve (e.g., 'chat', 'embedding', etc.) **kwargs: Additional arguments to pass to the model constructor """ + defaults = await self.get_defaults() model_id = None if model_type == "chat": - model_id = self.defaults.default_chat_model + model_id = defaults.default_chat_model elif model_type == "transformation": model_id = ( - self.defaults.default_transformation_model - or self.defaults.default_chat_model + defaults.default_transformation_model + or defaults.default_chat_model ) elif model_type == "tools": model_id = ( - self.defaults.default_tools_model or self.defaults.default_chat_model + defaults.default_tools_model or defaults.default_chat_model ) elif model_type == "embedding": - model_id = self.defaults.default_embedding_model + model_id = defaults.default_embedding_model elif model_type == "text_to_speech": - model_id = self.defaults.default_text_to_speech_model + model_id = defaults.default_text_to_speech_model elif model_type == "speech_to_text": - model_id = self.defaults.default_speech_to_text_model + model_id = defaults.default_speech_to_text_model elif model_type == "large_context": - model_id = self.defaults.large_context_model + model_id = defaults.large_context_model if not model_id: return None - return self.get_model(model_id, **kwargs) + return await self.get_model(model_id, **kwargs) def clear_cache(self): """Clear the model cache""" diff --git a/open_notebook/domain/notebook.py b/open_notebook/domain/notebook.py index 5387c52..a3fe316 100644 --- a/open_notebook/domain/notebook.py +++ b/open_notebook/domain/notebook.py @@ -1,14 +1,15 @@ +import asyncio from concurrent.futures import ThreadPoolExecutor from typing import Any, ClassVar, Dict, List, Literal, Optional, Tuple from loguru import logger from pydantic import BaseModel, Field, field_validator -from open_notebook.database.repository import repo_query +from open_notebook.database.repository import ensure_record_id, repo_query from open_notebook.domain.base import ObjectModel from open_notebook.domain.models import model_manager from open_notebook.exceptions import DatabaseOperationError, InvalidInputError -from open_notebook.utils import split_text, surreal_clean +from open_notebook.utils import split_text class Notebook(ObjectModel): @@ -24,54 +25,62 @@ class Notebook(ObjectModel): raise InvalidInputError("Notebook name cannot be empty") return v - @property - def sources(self) -> List["Source"]: + async def get_sources(self) -> List["Source"]: try: - srcs = repo_query(f""" + srcs = await repo_query( + """ select * omit source.full_text from ( - select in as source from reference where out={self.id} + select in as source from reference where out=$id fetch source ) order by source.updated desc - """) + """, + {"id": ensure_record_id(self.id)}, + ) return [Source(**src["source"]) for src in srcs] if srcs else [] except Exception as e: logger.error(f"Error fetching sources for notebook {self.id}: {str(e)}") logger.exception(e) raise DatabaseOperationError(e) - @property - def notes(self) -> List["Note"]: + async def get_notes(self) -> List["Note"]: try: - srcs = repo_query(f""" + srcs = await repo_query( + """ select * omit note.content, note.embedding from ( - select in as note from artifact where out={self.id} + select in as note from artifact where out=$id fetch note ) order by note.updated desc - """) + """, + {"id": ensure_record_id(self.id)}, + ) return [Note(**src["note"]) for src in srcs] if srcs else [] except Exception as e: logger.error(f"Error fetching notes for notebook {self.id}: {str(e)}") logger.exception(e) raise DatabaseOperationError(e) - @property - def chat_sessions(self) -> List["ChatSession"]: + async def get_chat_sessions(self) -> List["ChatSession"]: try: - srcs = repo_query(f""" + srcs = await repo_query( + """ select * from ( select <- chat_session as chat_session from refers_to - where out={self.id} + where out=$id fetch chat_session ) order by chat_session.updated desc - """) + """, + {"id": ensure_record_id(self.id)}, + ) return ( [ChatSession(**src["chat_session"][0]) for src in srcs] if srcs else [] ) except Exception as e: - logger.error(f"Error fetching notes for notebook {self.id}: {str(e)}") + logger.error( + f"Error fetching chat sessions for notebook {self.id}: {str(e)}" + ) logger.exception(e) raise DatabaseOperationError(e) @@ -85,13 +94,14 @@ class SourceEmbedding(ObjectModel): table_name: ClassVar[str] = "source_embedding" content: str - @property - def source(self) -> "Source": + async def get_source(self) -> "Source": try: - src = repo_query(f""" - select source.* from {self.id} fetch source - - """) + src = await repo_query( + """ + select source.* from $id fetch source + """, + {"id": ensure_record_id(self.id)}, + ) return Source(**src[0]["source"]) except Exception as e: logger.error(f"Error fetching source for embedding {self.id}: {str(e)}") @@ -104,27 +114,29 @@ class SourceInsight(ObjectModel): insight_type: str content: str - @property - def source(self) -> "Source": + async def get_source(self) -> "Source": try: - src = repo_query(f""" - select source.* from {self.id} fetch source - - """) + src = await repo_query( + """ + select source.* from $id fetch source + """, + {"id": ensure_record_id(self.id)}, + ) return Source(**src[0]["source"]) except Exception as e: logger.error(f"Error fetching source for insight {self.id}: {str(e)}") logger.exception(e) raise DatabaseOperationError(e) - def save_as_note(self, notebook_id: str = None) -> Any: + async def save_as_note(self, notebook_id: str = None) -> Any: + source = await self.get_source() note = Note( - title=f"{self.insight_type} from source {self.source.title}", + title=f"{self.insight_type} from source {source.title}", content=self.content, ) - note.save() + await note.save() if notebook_id: - note.add_to_notebook(notebook_id) + await note.add_to_notebook(notebook_id) return note @@ -135,10 +147,11 @@ class Source(ObjectModel): topics: Optional[List[str]] = Field(default_factory=list) full_text: Optional[str] = None - def get_context( + async def get_context( self, context_size: Literal["short", "long"] = "short" ) -> Dict[str, Any]: - insights = [insight.model_dump() for insight in self.insights] + insights_list = await self.get_insights() + insights = [insight.model_dump() for insight in insights_list] if context_size == "long": return dict( id=self.id, @@ -149,29 +162,29 @@ class Source(ObjectModel): else: return dict(id=self.id, title=self.title, insights=insights) - @property - def embedded_chunks(self) -> int: + async def get_embedded_chunks(self) -> int: try: - result = repo_query( - f""" - select count() as chunks from source_embedding where source={self.id} GROUP ALL + result = await repo_query( """ + select count() as chunks from source_embedding where source=$id GROUP ALL + """, + {"id": ensure_record_id(self.id)}, ) if len(result) == 0: return 0 return result[0]["chunks"] except Exception as e: - logger.error(f"Error fetching insights for source {self.id}: {str(e)}") + logger.error(f"Error fetching chunks count for source {self.id}: {str(e)}") logger.exception(e) raise DatabaseOperationError(f"Failed to count chunks for source: {str(e)}") - @property - def insights(self) -> List[SourceInsight]: + async def get_insights(self) -> List[SourceInsight]: try: - result = repo_query( - f""" - SELECT * FROM source_insight WHERE source={self.id} + result = await repo_query( """ + SELECT * FROM source_insight WHERE source=$id + """, + {"id": ensure_record_id(self.id)}, ) return [SourceInsight(**insight) for insight in result] except Exception as e: @@ -179,14 +192,14 @@ class Source(ObjectModel): logger.exception(e) raise DatabaseOperationError("Failed to fetch insights for source") - def add_to_notebook(self, notebook_id: str) -> Any: + async def add_to_notebook(self, notebook_id: str) -> Any: if not notebook_id: raise InvalidInputError("Notebook ID must be provided") - return self.relate("reference", notebook_id) + return await self.relate("reference", notebook_id) - def vectorize(self) -> None: + async def vectorize(self) -> None: logger.info(f"Starting vectorization for source {self.id}") - EMBEDDING_MODEL = model_manager.embedding_model + EMBEDDING_MODEL = await model_manager.get_embedding_model() try: if not self.full_text: @@ -203,40 +216,45 @@ class Source(ObjectModel): logger.warning("No chunks created after splitting") return - def process_chunk(args: Tuple[int, str]) -> Tuple[int, List[float], str]: - idx, chunk = args + # Process chunks concurrently using async gather + logger.info("Starting concurrent processing of chunks") + + async def process_chunk( + idx: int, chunk: str + ) -> Tuple[int, List[float], str]: logger.debug(f"Processing chunk {idx}/{chunk_count}") try: - embedding = EMBEDDING_MODEL.embed([chunk])[0] - cleaned_content = surreal_clean(chunk) + embedding = (await EMBEDDING_MODEL.aembed([chunk]))[0] + cleaned_content = chunk logger.debug(f"Successfully processed chunk {idx}") return (idx, embedding, cleaned_content) except Exception as e: logger.error(f"Error processing chunk {idx}: {str(e)}") raise - # Process chunks in parallel while preserving order - logger.info("Starting parallel processing of chunks") - with ThreadPoolExecutor(max_workers=8) as executor: - # Create list of (index, chunk) tuples - chunk_tasks = list(enumerate(chunks)) - # Process all chunks in parallel and get results - results = list(executor.map(process_chunk, chunk_tasks)) + # Create tasks for all chunks and process them concurrently + tasks = [process_chunk(idx, chunk) for idx, chunk in enumerate(chunks)] + results = await asyncio.gather(*tasks) logger.info(f"Parallel processing complete. Got {len(results)} results") # Insert results in order (they're already ordered by index) for idx, embedding, content in results: logger.debug(f"Inserting chunk {idx} into database") - repo_query( - f""" - CREATE source_embedding CONTENT {{ - "source": {self.id}, - "order": {idx}, + await repo_query( + """ + CREATE source_embedding CONTENT { + "source": $source_id, + "order": $order, "content": $content, - "embedding": {embedding}, - }};""", - {"content": content}, + "embedding": $embedding, + };""", + { + "source_id": ensure_record_id(self.id), + "order": idx, + "content": content, + "embedding": embedding, + }, ) logger.info(f"Vectorization complete for source {self.id}") @@ -246,24 +264,31 @@ class Source(ObjectModel): logger.exception(e) raise DatabaseOperationError(e) - def add_insight(self, insight_type: str, content: str) -> Any: - EMBEDDING_MODEL = model_manager.embedding_model + async def add_insight(self, insight_type: str, content: str) -> Any: + EMBEDDING_MODEL = await model_manager.get_embedding_model() if not EMBEDDING_MODEL: logger.warning("No embedding model found. Insight will not be searchable.") if not insight_type or not content: raise InvalidInputError("Insight type and content must be provided") try: - embedding = EMBEDDING_MODEL.embed([content])[0] if EMBEDDING_MODEL else [] - return repo_query( - f""" - CREATE source_insight CONTENT {{ - "source": {self.id}, - "insight_type": '{insight_type}', + embedding = ( + (await EMBEDDING_MODEL.aembed([content]))[0] if EMBEDDING_MODEL else [] + ) + return await repo_query( + """ + CREATE source_insight CONTENT { + "source": $source_id, + "insight_type": $insight_type, "content": $content, - "embedding": {embedding}, - }};""", - {"content": surreal_clean(content)}, + "embedding": $embedding, + };""", + { + "source_id": ensure_record_id(self.id), + "insight_type": insight_type, + "content": content, + "embedding": embedding, + }, ) except Exception as e: logger.error(f"Error adding insight to source {self.id}: {str(e)}") @@ -283,10 +308,10 @@ class Note(ObjectModel): raise InvalidInputError("Note content cannot be empty") return v - def add_to_notebook(self, notebook_id: str) -> Any: + async def add_to_notebook(self, notebook_id: str) -> Any: if not notebook_id: raise InvalidInputError("Notebook ID must be provided") - return self.relate("artifact", notebook_id) + return await self.relate("artifact", notebook_id) def get_context( self, context_size: Literal["short", "long"] = "short" @@ -311,17 +336,19 @@ class ChatSession(ObjectModel): table_name: ClassVar[str] = "chat_session" title: Optional[str] = None - def relate_to_notebook(self, notebook_id: str) -> Any: + async def relate_to_notebook(self, notebook_id: str) -> Any: if not notebook_id: raise InvalidInputError("Notebook ID must be provided") - return self.relate("refers_to", notebook_id) + return await self.relate("refers_to", notebook_id) -def text_search(keyword: str, results: int, source: bool = True, note: bool = True): +async def text_search( + keyword: str, results: int, source: bool = True, note: bool = True +): if not keyword: raise InvalidInputError("Search keyword cannot be empty") try: - results = repo_query( + results = await repo_query( """ select * from fn::text_search($keyword, $results, $source, $note) @@ -335,7 +362,7 @@ def text_search(keyword: str, results: int, source: bool = True, note: bool = Tr raise DatabaseOperationError(e) -def vector_search( +async def vector_search( keyword: str, results: int, source: bool = True, @@ -345,9 +372,9 @@ def vector_search( if not keyword: raise InvalidInputError("Search keyword cannot be empty") try: - EMBEDDING_MODEL = model_manager.embedding_model - embed = EMBEDDING_MODEL.embed([keyword])[0] - results = repo_query( + EMBEDDING_MODEL = await model_manager.get_embedding_model() + embed = (await EMBEDDING_MODEL.aembed([keyword]))[0] + results = await repo_query( """ SELECT * FROM fn::vector_search($embed, $results, $source, $note, $minimum_score); """, diff --git a/open_notebook/domain/podcast.py b/open_notebook/domain/podcast.py new file mode 100644 index 0000000..ad5ef44 --- /dev/null +++ b/open_notebook/domain/podcast.py @@ -0,0 +1,148 @@ +from typing import Any, ClassVar, Dict, List, Optional, Union + +from pydantic import Field, field_validator +from surrealdb import RecordID + +from open_notebook.database.repository import ensure_record_id, repo_query +from open_notebook.domain.base import ObjectModel + + +class EpisodeProfile(ObjectModel): + """ + Episode Profile - Simplified podcast configuration. + Replaces complex 15+ field configuration with user-friendly profiles. + """ + + table_name: ClassVar[str] = "episode_profile" + + name: str = Field(..., description="Unique profile name") + description: Optional[str] = Field(None, description="Profile description") + speaker_config: str = Field(..., description="Reference to speaker profile name") + outline_provider: str = Field(..., description="AI provider for outline generation") + outline_model: str = Field(..., description="AI model for outline generation") + transcript_provider: str = Field( + ..., description="AI provider for transcript generation" + ) + transcript_model: str = Field(..., description="AI model for transcript generation") + default_briefing: str = Field(..., description="Default briefing template") + num_segments: int = Field(default=5, description="Number of podcast segments") + + @field_validator("num_segments") + @classmethod + def validate_segments(cls, v): + if not 3 <= v <= 20: + raise ValueError("Number of segments must be between 3 and 20") + return v + + @classmethod + async def get_by_name(cls, name: str) -> Optional["EpisodeProfile"]: + """Get episode profile by name""" + result = await repo_query( + "SELECT * FROM episode_profile WHERE name = $name", {"name": name} + ) + if result: + return cls(**result[0]) + return None + + +class SpeakerProfile(ObjectModel): + """ + Speaker Profile - Voice and personality configuration. + Supports 1-4 speakers for flexible podcast formats. + """ + + table_name: ClassVar[str] = "speaker_profile" + + name: str = Field(..., description="Unique profile name") + description: Optional[str] = Field(None, description="Profile description") + tts_provider: str = Field( + ..., description="TTS provider (openai, elevenlabs, etc.)" + ) + tts_model: str = Field(..., description="TTS model name") + speakers: List[Dict[str, Any]] = Field( + ..., description="Array of speaker configurations" + ) + + @field_validator("speakers") + @classmethod + def validate_speakers(cls, v): + if not 1 <= len(v) <= 4: + raise ValueError("Must have between 1 and 4 speakers") + + required_fields = ["name", "voice_id", "backstory", "personality"] + for speaker in v: + for field in required_fields: + if field not in speaker: + raise ValueError(f"Speaker missing required field: {field}") + return v + + @classmethod + async def get_by_name(cls, name: str) -> Optional["SpeakerProfile"]: + """Get speaker profile by name""" + result = await repo_query( + "SELECT * FROM speaker_profile WHERE name = $name", {"name": name} + ) + if result: + return cls(**result[0]) + return None + + +class PodcastEpisode(ObjectModel): + """Enhanced PodcastEpisode with job tracking and metadata""" + + table_name: ClassVar[str] = "episode" + + name: str = Field(..., description="Episode name") + episode_profile: Dict[str, Any] = Field( + ..., description="Episode profile used (stored as object)" + ) + speaker_profile: Dict[str, Any] = Field( + ..., description="Speaker profile used (stored as object)" + ) + briefing: str = Field(..., description="Full briefing used for generation") + content: str = Field(..., description="Source content") + audio_file: Optional[str] = Field( + default=None, description="Path to generated audio file" + ) + transcript: Optional[Dict[str, Any]] = Field( + default_factory=dict, description="Generated transcript" + ) + outline: Optional[Dict[str, Any]] = Field( + default_factory=dict, description="Generated outline" + ) + command: Optional[Union[str, RecordID]] = Field( + default=None, description="Link to surreal-commands job" + ) + + class Config: + arbitrary_types_allowed = True + + async def get_job_status(self) -> Optional[str]: + """Get the status of the associated command""" + if not self.command: + return None + + try: + from surreal_commands import get_command_status + + status = await get_command_status(str(self.command)) + return status.status if status else "unknown" + except Exception: + return "unknown" + + @field_validator("command", mode="before") + @classmethod + def parse_command(cls, value): + if isinstance(value, str): + return ensure_record_id(value) + return value + + def _prepare_save_data(self) -> dict: + """Override to ensure command field is always RecordID format for database""" + data = super()._prepare_save_data() + + # Ensure command field is RecordID format if not None + if data.get("command") is not None: + data["command"] = ensure_record_id(data["command"]) + + return data diff --git a/open_notebook/graphs/ask.py b/open_notebook/graphs/ask.py index 9f639a6..69553d6 100644 --- a/open_notebook/graphs/ask.py +++ b/open_notebook/graphs/ask.py @@ -53,7 +53,7 @@ async def call_model_with_messages(state: ThreadState, config: RunnableConfig) - system_prompt = Prompter(prompt_template="ask/entry", parser=parser).render( data=state ) - model = provision_langchain_model( + model = await provision_langchain_model( system_prompt, config.get("configurable", {}).get("strategy_model"), "tools", @@ -62,14 +62,14 @@ async def call_model_with_messages(state: ThreadState, config: RunnableConfig) - ) # model = model.bind_tools(tools) # First get the raw response from the model - ai_message = model.invoke(system_prompt) - + ai_message = await model.ainvoke(system_prompt) + # Clean the thinking content from the response cleaned_content = clean_thinking_content(ai_message.content) - + # Parse the cleaned JSON content strategy = parser.parse(cleaned_content) - + return {"strategy": strategy} @@ -93,32 +93,32 @@ async def provide_answer(state: SubGraphState, config: RunnableConfig) -> dict: # if state["type"] == "text": # results = text_search(state["term"], 10, True, True) # else: - results = vector_search(state["term"], 10, True, True) + results = await vector_search(state["term"], 10, True, True) if len(results) == 0: return {"answers": []} payload["results"] = results ids = [r["id"] for r in results] payload["ids"] = ids system_prompt = Prompter(prompt_template="ask/query_process").render(data=payload) - model = provision_langchain_model( + model = await provision_langchain_model( system_prompt, config.get("configurable", {}).get("answer_model"), "tools", max_tokens=2000, ) - ai_message = model.invoke(system_prompt) + ai_message = await model.ainvoke(system_prompt) return {"answers": [clean_thinking_content(ai_message.content)]} async def write_final_answer(state: ThreadState, config: RunnableConfig) -> dict: system_prompt = Prompter(prompt_template="ask/final_answer").render(data=state) - model = provision_langchain_model( + model = await provision_langchain_model( system_prompt, config.get("configurable", {}).get("final_answer_model"), "tools", max_tokens=2000, ) - ai_message = model.invoke(system_prompt) + ai_message = await model.ainvoke(system_prompt) return {"final_answer": clean_thinking_content(ai_message.content)} diff --git a/open_notebook/graphs/chat.py b/open_notebook/graphs/chat.py index afbf054..00075e3 100644 --- a/open_notebook/graphs/chat.py +++ b/open_notebook/graphs/chat.py @@ -1,11 +1,10 @@ +import asyncio import sqlite3 from typing import Annotated, Optional from ai_prompter import Prompter from langchain_core.messages import SystemMessage -from langchain_core.runnables import ( - RunnableConfig, -) +from langchain_core.runnables import RunnableConfig from langgraph.checkpoint.sqlite import SqliteSaver from langgraph.graph import END, START, StateGraph from langgraph.graph.message import add_messages @@ -26,11 +25,13 @@ class ThreadState(TypedDict): def call_model_with_messages(state: ThreadState, config: RunnableConfig) -> dict: system_prompt = Prompter(prompt_template="chat").render(data=state) payload = [SystemMessage(content=system_prompt)] + state.get("messages", []) - model = provision_langchain_model( - str(payload), - config.get("configurable", {}).get("model_id"), - "chat", - max_tokens=2000, + model = asyncio.run( + provision_langchain_model( + str(payload), + config.get("configurable", {}).get("model_id"), + "chat", + max_tokens=10000, + ) ) ai_message = model.invoke(payload) return {"messages": ai_message} diff --git a/open_notebook/graphs/prompt.py b/open_notebook/graphs/prompt.py index 574e399..cc48b39 100644 --- a/open_notebook/graphs/prompt.py +++ b/open_notebook/graphs/prompt.py @@ -17,21 +17,20 @@ class PatternChainState(TypedDict): output: str -def call_model(state: dict, config: RunnableConfig) -> dict: +async def call_model(state: dict, config: RunnableConfig) -> dict: content = state["input_text"] system_prompt = Prompter( template_text=state["prompt"], parser=state.get("parser") ).render(data=state) - logger.warning(content) payload = [SystemMessage(content=system_prompt)] + [HumanMessage(content=content)] - chain = provision_langchain_model( + chain = await provision_langchain_model( str(payload), config.get("configurable", {}).get("model_id"), "transformation", max_tokens=5000, ) - response = chain.invoke(payload) + response = await chain.ainvoke(payload) return {"output": response.content} diff --git a/open_notebook/graphs/source.py b/open_notebook/graphs/source.py index 4807ded..db3cb9b 100644 --- a/open_notebook/graphs/source.py +++ b/open_notebook/graphs/source.py @@ -13,7 +13,6 @@ from open_notebook.domain.content_settings import ContentSettings from open_notebook.domain.notebook import Asset, Source from open_notebook.domain.transformation import Transformation from open_notebook.graphs.transformation import graph as transform_graph -from open_notebook.utils import surreal_clean class SourceState(TypedDict): @@ -46,23 +45,23 @@ async def content_process(state: SourceState) -> dict: return {"content_state": processed_state} -def save_source(state: SourceState) -> dict: +async def save_source(state: SourceState) -> dict: content_state = state["content_state"] source = Source( asset=Asset(url=content_state.url, file_path=content_state.file_path), - full_text=surreal_clean(content_state.content), + full_text=content_state.content, title=content_state.title, ) - source.save() + await source.save() if state["notebook_id"]: logger.debug(f"Adding source to notebook {state['notebook_id']}") - source.add_to_notebook(state["notebook_id"]) + await source.add_to_notebook(state["notebook_id"]) if state["embed"]: logger.debug("Embedding content for vector search") - source.vectorize() + await source.vectorize() return {"source": source} @@ -97,7 +96,7 @@ async def transform_content(state: TransformationState) -> Optional[dict]: result = await transform_graph.ainvoke( dict(input_text=content, transformation=transformation) ) - source.add_insight(transformation.title, surreal_clean(result["output"])) + await source.add_insight(transformation.title, result["output"]) return { "transformation": [ { diff --git a/open_notebook/graphs/transformation.py b/open_notebook/graphs/transformation.py index 360ab4b..289d0ed 100644 --- a/open_notebook/graphs/transformation.py +++ b/open_notebook/graphs/transformation.py @@ -17,7 +17,7 @@ class TransformationState(TypedDict): output: str -def run_transformation(state: dict, config: RunnableConfig) -> dict: +async def run_transformation(state: dict, config: RunnableConfig) -> dict: source: Source = state.get("source") content = state.get("input_text") assert source or content, "No content to transform" @@ -35,20 +35,20 @@ def run_transformation(state: dict, config: RunnableConfig) -> dict: data=state ) payload = [SystemMessage(content=system_prompt)] + [HumanMessage(content=content)] - chain = provision_langchain_model( + chain = await provision_langchain_model( str(payload), config.get("configurable", {}).get("model_id"), "transformation", - max_tokens=5000, + max_tokens=5055, ) - response = chain.invoke(payload) - + response = await chain.ainvoke(payload) + # Clean thinking content from the response cleaned_content = clean_thinking_content(response.content) - + if source: - source.add_insight(transformation.title, cleaned_content) + await source.add_insight(transformation.title, cleaned_content) return { "output": cleaned_content, diff --git a/open_notebook/graphs/utils.py b/open_notebook/graphs/utils.py index e6a256b..05264e2 100644 --- a/open_notebook/graphs/utils.py +++ b/open_notebook/graphs/utils.py @@ -6,7 +6,7 @@ from open_notebook.domain.models import model_manager from open_notebook.utils import token_count -def provision_langchain_model( +async def provision_langchain_model( content, model_id, default_type, **kwargs ) -> BaseChatModel: """ @@ -21,11 +21,11 @@ def provision_langchain_model( logger.debug( f"Using large context model because the content has {tokens} tokens" ) - model = model_manager.get_default_model("large_context", **kwargs) + model = await model_manager.get_default_model("large_context", **kwargs) elif model_id: - model = model_manager.get_model(model_id, **kwargs) + model = await model_manager.get_model(model_id, **kwargs) else: - model = model_manager.get_default_model(default_type, **kwargs) + model = await model_manager.get_default_model(default_type, **kwargs) logger.debug(f"Using model: {model}") assert isinstance(model, LanguageModel), f"Model is not a LanguageModel: {model}" diff --git a/open_notebook/plugins/podcasts.py b/open_notebook/plugins/podcasts.py index b7442fb..9afabac 100644 --- a/open_notebook/plugins/podcasts.py +++ b/open_notebook/plugins/podcasts.py @@ -52,7 +52,7 @@ class PodcastConfig(ObjectModel): raise ValueError("Both voice1 and voice2 must be provided") return self - def generate_episode( + async def generate_episode( self, episode_name: str, text: str, @@ -142,7 +142,7 @@ class PodcastConfig(ObjectModel): text=str(text), audio_file=audio_file, ) - episode.save() + await episode.save() except Exception as e: logger.error(f"Failed to generate episode {episode_name}: {e}") raise diff --git a/open_notebook/utils.py b/open_notebook/utils.py index a32d6eb..cf4f07a 100644 --- a/open_notebook/utils.py +++ b/open_notebook/utils.py @@ -100,27 +100,6 @@ def remove_non_printable(text) -> str: return re.sub(r"[^\w\s.,!?\-\n\t]", "", text, flags=re.UNICODE) -def surreal_clean(text) -> str: - """ - Clean the input text by removing non-ASCII and non-printable characters, - and adjusting colon placement for SurrealDB compatibility. - - Args: - text (str): The input text to clean. - Returns: - str: The cleaned text with adjusted formatting. - """ - text = remove_non_printable(text) - - # Add space after colon if it's before the first space - first_space_index = text.find(" ") - colon_index = text.find(":") - if colon_index != -1 and ( - first_space_index == -1 or colon_index < first_space_index - ): - text = text.replace(":", "\:", 1) - - return text def get_version_from_github(repo_url: str, branch: str = "main") -> str: diff --git a/open_notebook_config.yaml b/open_notebook_config.yaml deleted file mode 100644 index 13794f2..0000000 --- a/open_notebook_config.yaml +++ /dev/null @@ -1,57 +0,0 @@ - -youtube_transcripts: - preferred_languages: - - en - - pt - - es - - de - - nl - - en-GB - - fr - - de - - hi - - ja -suggested_models: - openai: - language: - - gpt-4o-mini - - gpt-4o - embedding: - - text-embedding-3-small - text_to_speech: - - tts-1-hd - speech_to_text: - - whisper-1 - google: - language: - - gemini-2.0-flash - - gemini-2.5-pro-preview-06-05 - text_to_speech: - - gemini-2.5-flash-preview-tts - xai: - language: - - grok-beta - anthropic: - language: - - claude-3-5-sonnet-latest - elevenlabs: - text_to_speech: - - eleven_turbo_v2_5 - xai: - language: - - grok-3 - - grok-3-mini - ollama: - language: - - qwen:14b - embedding: - - mxbai-embed-large - deepseek: - language: - - deepseek-chat - mistral: - language: - - mistral-large-latest - voyage: - embedding: - - voyage-3.5-lite \ No newline at end of file diff --git a/pages/10_⚙️_Settings.py b/pages/10_⚙️_Settings.py index 7b38e84..0a07c48 100644 --- a/pages/10_⚙️_Settings.py +++ b/pages/10_⚙️_Settings.py @@ -2,14 +2,14 @@ import os import streamlit as st -from open_notebook.domain.content_settings import ContentSettings +from api.settings_service import settings_service from pages.stream_app.utils import setup_page setup_page("⚙️ Settings") st.header("⚙️ Settings") -content_settings = ContentSettings() +content_settings = settings_service.get_settings() with st.container(border=True): st.markdown("**Content Processing Engine for Documents**") @@ -109,6 +109,183 @@ with st.container(border=True): "\n\n- Choose **yes** if you are running a local embedding model or if your content volume is not that big\n- Choose **ask** if you want to decide every time\n- Choose **never** if you don't care about vector search or do not have an embedding provider." ) +with st.container(border=True): + st.markdown("**YouTube Preferred Languages**") + st.caption( + "Languages to prioritize when downloading YouTube transcripts (in order of preference). If the video does not include these languages, we'll get the best transcript possible. Don't worry, the language model will still be able to understand it. " + ) + + # Available language options with descriptions + language_options = { + "af": "Afrikaans", + "ak": "Akan", + "sq": "Albanian", + "am": "Amharic", + "ar": "Arabic", + "hy": "Armenian", + "as": "Assamese", + "ay": "Aymara", + "az": "Azerbaijani", + "bn": "Bangla", + "eu": "Basque", + "be": "Belarusian", + "bho": "Bhojpuri", + "bs": "Bosnian", + "bg": "Bulgarian", + "my": "Burmese", + "ca": "Catalan", + "ceb": "Cebuano", + "zh": "Chinese", + "zh-HK": "Chinese (Hong Kong)", + "zh-CN": "Chinese (China)", + "zh-SG": "Chinese (Singapore)", + "zh-TW": "Chinese (Taiwan)", + "zh-Hans": "Chinese (Simplified)", + "zh-Hant": "Chinese (Traditional)", + "hak-TW": "Hakka Chinese (Taiwan)", + "nan-TW": "Min Nan Chinese (Taiwan)", + "co": "Corsican", + "hr": "Croatian", + "cs": "Czech", + "da": "Danish", + "dv": "Divehi", + "nl": "Dutch", + "en": "English", + "en-US": "English (United States)", + "eo": "Esperanto", + "et": "Estonian", + "ee": "Ewe", + "fil": "Filipino", + "fi": "Finnish", + "fr": "French", + "gl": "Galician", + "lg": "Ganda", + "ka": "Georgian", + "de": "German", + "el": "Greek", + "gn": "Guarani", + "gu": "Gujarati", + "ht": "Haitian Creole", + "ha": "Hausa", + "haw": "Hawaiian", + "iw": "Hebrew", + "hi": "Hindi", + "hmn": "Hmong", + "hu": "Hungarian", + "is": "Icelandic", + "ig": "Igbo", + "id": "Indonesian", + "ga": "Irish", + "it": "Italian", + "ja": "Japanese", + "jv": "Javanese", + "kn": "Kannada", + "kk": "Kazakh", + "km": "Khmer", + "rw": "Kinyarwanda", + "ko": "Korean", + "kri": "Krio", + "ku": "Kurdish", + "ky": "Kyrgyz", + "lo": "Lao", + "la": "Latin", + "lv": "Latvian", + "ln": "Lingala", + "lt": "Lithuanian", + "lb": "Luxembourgish", + "mk": "Macedonian", + "mg": "Malagasy", + "ms": "Malay", + "ml": "Malayalam", + "mt": "Maltese", + "mi": "Māori", + "mr": "Marathi", + "mn": "Mongolian", + "ne": "Nepali", + "nso": "Northern Sotho", + "no": "Norwegian", + "ny": "Nyanja", + "or": "Odia", + "om": "Oromo", + "ps": "Pashto", + "fa": "Persian", + "pl": "Polish", + "pt": "Portuguese", + "pa": "Punjabi", + "qu": "Quechua", + "ro": "Romanian", + "ru": "Russian", + "sm": "Samoan", + "sa": "Sanskrit", + "gd": "Scottish Gaelic", + "sr": "Serbian", + "sn": "Shona", + "sd": "Sindhi", + "si": "Sinhala", + "sk": "Slovak", + "sl": "Slovenian", + "so": "Somali", + "st": "Southern Sotho", + "es": "Spanish", + "su": "Sundanese", + "sw": "Swahili", + "sv": "Swedish", + "tg": "Tajik", + "ta": "Tamil", + "tt": "Tatar", + "te": "Telugu", + "th": "Thai", + "ti": "Tigrinya", + "ts": "Tsonga", + "tr": "Turkish", + "tk": "Turkmen", + "uk": "Ukrainian", + "ur": "Urdu", + "ug": "Uyghur", + "uz": "Uzbek", + "vi": "Vietnamese", + "cy": "Welsh", + "fy": "Western Frisian", + "xh": "Xhosa", + "yi": "Yiddish", + "yo": "Yoruba", + "zu": "Zulu", + "en-GB": "English (UK)", + } + + # Get current preferred languages or use defaults + current_languages = content_settings.youtube_preferred_languages or [ + "en", + "pt", + "es", + "de", + "nl", + "en-GB", + "fr", + "de", + "hi", + "ja", + ] + + youtube_preferred_languages = st.multiselect( + "Select preferred languages (in order of preference)", + options=list(language_options.keys()), + default=current_languages, + format_func=lambda x: f"{language_options[x]} ({x})", + help="YouTube transcripts will be downloaded in the first available language from this list", + ) + + with st.expander("Help me choose"): + st.markdown( + "When processing YouTube videos, Open Notebook will try to download transcripts in your preferred languages. " + "The order matters - it will try the first language first, then the second if the first isn't available, and so on. " + "If none of your preferred languages are available, it will fall back to any available transcript." + ) + st.markdown( + "**Tip**: Put your most preferred language first. For example, if you speak both English and Spanish, " + "but prefer English content, put 'en' before 'es' in your selection." + ) + if st.button("Save", key="save_settings"): content_settings.default_content_processing_engine_doc = ( default_content_processing_engine_doc @@ -118,5 +295,6 @@ if st.button("Save", key="save_settings"): ) content_settings.default_embedding_option = default_embedding_option content_settings.auto_delete_files = auto_delete_files - content_settings.update() + content_settings.youtube_preferred_languages = youtube_preferred_languages + settings_service.update_settings(content_settings) st.toast("Settings saved successfully!") diff --git a/pages/2_📒_Notebooks.py b/pages/2_📒_Notebooks.py index 0d0c005..4f7b78b 100644 --- a/pages/2_📒_Notebooks.py +++ b/pages/2_📒_Notebooks.py @@ -1,6 +1,9 @@ import streamlit as st from humanize import naturaltime +from api.notebook_service import notebook_service +from api.notes_service import notes_service +from api.sources_service import sources_service from open_notebook.domain.notebook import Notebook from pages.stream_app.chat import chat_sidebar from pages.stream_app.note import add_note, note_card @@ -38,20 +41,20 @@ def notebook_header(current_notebook: Notebook): if c1.button("Save", icon="💾", key="edit_notebook"): current_notebook.name = notebook_name current_notebook.description = notebook_description - current_notebook.save() + notebook_service.update_notebook(current_notebook) st.rerun() if not current_notebook.archived: if c2.button("Archive", icon="🗃️"): current_notebook.archived = True - current_notebook.save() + notebook_service.update_notebook(current_notebook) st.toast("Notebook archived", icon="🗃️") else: if c2.button("Unarchive", icon="🗃️"): current_notebook.archived = False - current_notebook.save() + notebook_service.update_notebook(current_notebook) st.toast("Notebook unarchived", icon="🗃️") if c3.button("Delete forever", type="primary", icon="☠️"): - current_notebook.delete() + notebook_service.delete_notebook(current_notebook) st.session_state["current_notebook_id"] = None st.rerun() @@ -66,8 +69,8 @@ def notebook_page(current_notebook: Notebook): current_notebook=current_notebook, ) - sources = current_notebook.sources - notes = current_notebook.notes + sources = sources_service.get_all_sources(notebook_id=current_notebook.id) + notes = notes_service.get_all_notes(notebook_id=current_notebook.id) notebook_header(current_notebook) @@ -108,7 +111,7 @@ if "current_notebook_id" not in st.session_state: # todo: get the notebook, check if it exists and if it's archived if st.session_state["current_notebook_id"]: - current_notebook: Notebook = Notebook.get(st.session_state["current_notebook_id"]) + current_notebook: Notebook = notebook_service.get_notebook(st.session_state["current_notebook_id"]) if not current_notebook: st.error("Notebook not found") st.stop() @@ -127,13 +130,12 @@ with st.expander("➕ **New Notebook**"): placeholder="Explain the purpose of this notebook. The more details the better.", ) if st.button("Create a new Notebook", icon="➕"): - notebook = Notebook( + notebook = notebook_service.create_notebook( name=new_notebook_title, description=new_notebook_description ) - notebook.save() st.toast("Notebook created successfully", icon="📒") -notebooks = Notebook.get_all(order_by="updated desc") +notebooks = notebook_service.get_all_notebooks(order_by="updated desc") archived_notebooks = [nb for nb in notebooks if nb.archived] for notebook in notebooks: diff --git a/pages/3_🔍_Ask_and_Search.py b/pages/3_🔍_Ask_and_Search.py index def0b0c..0f3e92e 100644 --- a/pages/3_🔍_Ask_and_Search.py +++ b/pages/3_🔍_Ask_and_Search.py @@ -1,15 +1,14 @@ -import asyncio - -import nest_asyncio import streamlit as st -from open_notebook.domain.models import DefaultModels, model_manager -from open_notebook.domain.notebook import Note, Notebook, text_search, vector_search -from open_notebook.graphs.ask import graph as ask_graph +from api.models_service import ModelsService +from api.notebook_service import notebook_service +from api.notes_service import notes_service +from api.search_service import search_service from pages.components.model_selector import model_selector from pages.stream_app.utils import convert_source_references, setup_page -nest_asyncio.apply() +# Initialize service instances +models_service = ModelsService() setup_page("🔍 Search") @@ -22,23 +21,6 @@ if "ask_results" not in st.session_state: st.session_state["ask_results"] = {} -async def process_ask_query(question, strategy_model, answer_model, final_answer_model): - async for chunk in ask_graph.astream( - input=dict( - question=question, - ), - config=dict( - configurable=dict( - strategy_model=strategy_model.id, - answer_model=answer_model.id, - final_answer_model=final_answer_model.id, - ) - ), - stream_mode="updates", - ): - yield (chunk) - - def results_card(item): with st.container(border=True): st.markdown( @@ -56,7 +38,8 @@ with ask_tab: "The LLM will answer your query based on the documents in your knowledge base. " ) question = st.text_input("Question", "") - default_model = DefaultModels().default_chat_model + default_models = models_service.get_default_models() + default_model = default_models.default_chat_model strategy_model = model_selector( "Query Strategy Model", "strategy_model", @@ -78,59 +61,53 @@ with ask_tab: selected_id=default_model, help="This is the LLM that will be responsible for processing the final answer", ) - if not model_manager.embedding_model: + embedding_model = default_models.default_embedding_model + if not embedding_model: st.warning( "You can't use this feature because you have no embedding model selected. Please set one up in the Models page." ) - ask_bt = st.button("Ask") if model_manager.embedding_model else None + ask_bt = st.button("Ask") if embedding_model else None placeholder = st.container() - async def stream_results(): - async for chunk in process_ask_query( - question, strategy_model, answer_model, final_answer_model - ): - if "agent" in chunk: - with placeholder.expander( - f"Agent Strategy: {chunk['agent']['strategy'].reasoning}" - ): - for search in chunk["agent"]["strategy"].searches: - st.markdown(f"Searched for: **{search.term}**") - st.markdown(f"Instructions: {search.instructions}") - elif "provide_answer" in chunk: - for answer in chunk["provide_answer"]["answers"]: - with placeholder.expander("Answer"): - st.markdown(convert_source_references(answer)) - elif "write_final_answer" in chunk: - st.session_state["ask_results"]["answer"] = chunk["write_final_answer"][ - "final_answer" - ] - with placeholder.container(border=True): - st.markdown( - convert_source_references( - chunk["write_final_answer"]["final_answer"] - ) - ) - if ask_bt: placeholder.write(f"Searching for {question}") st.session_state["ask_results"]["question"] = question st.session_state["ask_results"]["answer"] = None - asyncio.run(stream_results()) + with st.spinner("Processing your question..."): + try: + result = search_service.ask_knowledge_base( + question=question, + strategy_model=strategy_model.id, + answer_model=answer_model.id, + final_answer_model=final_answer_model.id, + ) + + if result.get("answer"): + st.session_state["ask_results"]["answer"] = result["answer"] + with placeholder.container(border=True): + st.markdown(convert_source_references(result["answer"])) + else: + placeholder.error("No answer generated") + + except Exception as e: + placeholder.error(f"Error processing question: {str(e)}") if st.session_state["ask_results"].get("answer"): with st.container(border=True): with st.form("save_note_form"): notebook = st.selectbox( - "Notebook", Notebook.get_all(), format_func=lambda x: x.name + "Notebook", + notebook_service.get_all_notebooks(), + format_func=lambda x: x.name, ) if st.form_submit_button("Save Answer as Note"): - note = Note( + notes_service.create_note( title=st.session_state["ask_results"]["question"], content=st.session_state["ask_results"]["answer"], + note_type="ai", + notebook_id=notebook.id, ) - note.save() - note.add_to_notebook(notebook.id) st.success("Note saved successfully") @@ -139,7 +116,7 @@ with search_tab: st.subheader("🔍 Search") st.caption("Search your knowledge base for specific keywords or concepts") search_term = st.text_input("Search", "") - if not model_manager.embedding_model: + if not embedding_model: st.warning( "You can't use vector search because you have no embedding model selected. Only text search will be available." ) @@ -149,16 +126,15 @@ with search_tab: search_sources = st.checkbox("Search Sources", value=True) search_notes = st.checkbox("Search Notes", value=True) if st.button("Search"): - if search_type == "Text Search": - st.write(f"Searching for {search_term}") - st.session_state["search_results"] = text_search( - search_term, 100, search_sources, search_notes - ) - elif search_type == "Vector Search": - st.write(f"Searching for {search_term}") - st.session_state["search_results"] = vector_search( - search_term, 100, search_sources, search_notes - ) + st.write(f"Searching for {search_term}") + search_type_api = "text" if search_type == "Text Search" else "vector" + st.session_state["search_results"] = search_service.search( + query=search_term, + search_type=search_type_api, + limit=100, + search_sources=search_sources, + search_notes=search_notes, + ) search_results = st.session_state["search_results"].copy() for item in search_results: diff --git a/pages/5_🎙️_Podcasts.py b/pages/5_🎙️_Podcasts.py index c77321a..1627aac 100644 --- a/pages/5_🎙️_Podcasts.py +++ b/pages/5_🎙️_Podcasts.py @@ -1,315 +1,1356 @@ -from typing import Dict, List +import asyncio +from datetime import datetime import streamlit as st -from streamlit_tags import st_tags -from open_notebook.domain.models import Model -from open_notebook.plugins.podcasts import ( - PodcastConfig, - PodcastEpisode, - conversation_styles, - dialogue_structures, - engagement_techniques, - participant_roles, -) +from api.models_service import models_service +from api.podcast_api_service import podcast_api_service +from open_notebook.database.repository import repo_query from pages.stream_app.utils import setup_page setup_page("🎙️ Podcasts", only_check_mandatory_models=False) -text_to_speech_models = Model.get_models_by_type("text_to_speech") +# Service instance is imported above -provider_models: Dict[str, List[str]] = {} +@st.dialog("Confirm Delete Episode") +def confirm_delete_episode(episode_id, episode_name): + st.warning(f"Are you sure you want to delete episode **{episode_name}**?") + st.write("This action will:") + st.write("• Delete the episode from the database") + st.write("• Delete the audio file from disk (if it exists)") + st.error("**This action cannot be undone!**") + + col_confirm1, col_confirm2 = st.columns(2) + with col_confirm1: + if st.button("✅ Yes, Delete", type="primary"): + success = delete_episode(episode_id) + if success: + st.success("Episode deleted successfully!") + st.rerun() + else: + st.error("Failed to delete episode") + + with col_confirm2: + if st.button("❌ Cancel"): + st.rerun() + + +@st.dialog("Confirm Delete Speaker Profile") +def confirm_delete_speaker_profile(profile_id, profile_name): + st.warning(f"Are you sure you want to delete speaker profile **{profile_name}**?") + + # Check usage before allowing deletion + speaker_profiles = fetch_speaker_profiles() + episode_profiles = fetch_episode_profiles() + usage_map = analyze_speaker_usage(speaker_profiles, episode_profiles) + + usage_count = usage_map.get(profile_name, 0) + + if usage_count > 0: + st.error(f"❌ **Cannot delete this speaker profile!**") + st.write( + f"This speaker profile is currently used by **{usage_count} episode profile(s)**." + ) + st.write("**To delete this speaker profile:**") + st.write("1. First update or delete the episode profiles that use this speaker") + st.write("2. Then return here to delete the speaker profile") + + # Show which episodes use this speaker + using_episodes = [] + for episode in episode_profiles: + if episode.get("speaker_config") == profile_name: + using_episodes.append(episode.get("name", "Unknown")) + + if using_episodes: + st.write("**Episodes using this speaker:**") + for ep_name in using_episodes: + st.write(f"• {ep_name}") + + if st.button("❌ Close"): + st.rerun() + return + + # Safe to delete - no usage + st.write("✅ This speaker profile is not used by any episode profiles.") + st.write("This action cannot be undone.") + + col_confirm1, col_confirm2 = st.columns(2) + with col_confirm1: + if st.button("✅ Yes, Delete", type="primary"): + success = delete_speaker_profile(profile_id) + if success: + st.success("Speaker profile deleted!") + st.rerun() + else: + st.error("Failed to delete speaker profile") + + with col_confirm2: + if st.button("❌ Cancel"): + st.rerun() + + +@st.dialog("Confirm Delete Episode Profile") +def confirm_delete_episode_profile(profile_id, profile_name): + st.warning(f"Are you sure you want to delete episode profile **{profile_name}**?") + st.write("This action cannot be undone.") + + col_confirm1, col_confirm2 = st.columns(2) + with col_confirm1: + if st.button("✅ Yes, Delete", type="primary"): + success = delete_episode_profile(profile_id) + if success: + st.success("Episode profile deleted!") + st.rerun() + else: + st.error("Failed to delete episode profile") + + with col_confirm2: + if st.button("❌ Cancel"): + st.rerun() + + +@st.fragment +def speaker_management_fragment(): + """Fragment for managing speakers within the dialog""" + st.subheader("🎙️ Speakers (1-4 speakers)") + + # Add Speaker button at top + if st.button("➕ Add Speaker", disabled=len(st.session_state.dialog_speakers) >= 4): + st.session_state.dialog_speakers.append( + {"name": "", "voice_id": "", "backstory": "", "personality": ""} + ) + st.rerun(scope="fragment") + + # Display current speakers with individual delete buttons + for i, speaker in enumerate(st.session_state.dialog_speakers): + with st.container(border=True): + col_header, col_delete = st.columns([4, 1]) + + with col_header: + st.write(f"**Speaker {i + 1}:**") + + with col_delete: + # Individual delete button for each speaker + if st.button( + "🗑️", + key=f"delete_speaker_{i}", + help=f"Delete Speaker {i + 1}", + disabled=len(st.session_state.dialog_speakers) <= 1, + ): + st.session_state.dialog_speakers.pop(i) + st.rerun(scope="fragment") + + col_spk1, col_spk2 = st.columns(2) + + with col_spk1: + speaker["name"] = st.text_input( + "Name*", + value=speaker.get("name", ""), + key=f"dialog_speaker_{i}_name", + ) + speaker["voice_id"] = st.text_input( + "Voice ID*", + value=speaker.get("voice_id", ""), + key=f"dialog_speaker_{i}_voice", + ) + + with col_spk2: + speaker["backstory"] = st.text_area( + "Backstory*", + value=speaker.get("backstory", ""), + key=f"dialog_speaker_{i}_backstory", + ) + speaker["personality"] = st.text_area( + "Personality*", + value=speaker.get("personality", ""), + key=f"dialog_speaker_{i}_personality", + ) + + +@st.dialog("Configure Speaker Profile", width="large") +def speaker_configuration_dialog(mode="create", profile_id=None, episode_context=None): + """Unified dialog for speaker profile create/edit/select""" + + # Handle mode switching from select to create + if st.session_state.get("switch_to_create", False): + mode = "create" + del st.session_state.switch_to_create + + # Initialize session state for dialog + if "dialog_speakers" not in st.session_state: + st.session_state.dialog_speakers = [ + {"name": "", "voice_id": "", "backstory": "", "personality": ""} + ] + + if mode == "create": + st.subheader("🎤 Create New Speaker Profile") + elif mode == "edit": + st.subheader("✏️ Edit Speaker Profile") + # Load existing profile data + if profile_id and "dialog_loaded" not in st.session_state: + speaker_profiles = fetch_speaker_profiles() + profile = next((p for p in speaker_profiles if p["id"] == profile_id), None) + if profile: + st.session_state.dialog_loaded = True + st.session_state.dialog_speakers = profile.get("speakers", []) + st.session_state.dialog_name = profile.get("name", "") + st.session_state.dialog_description = profile.get("description", "") + st.session_state.dialog_tts_provider = profile.get("tts_provider", "") + st.session_state.dialog_tts_model = profile.get("tts_model", "") + elif mode == "select": + st.subheader("⚙️ Configure Speaker for Episode") + + # Fetch available speaker profiles + speaker_profiles = fetch_speaker_profiles() + + if not speaker_profiles: + st.warning("No speaker profiles available. Create one first.") + if st.button("✅ Create New Speaker Profile"): + # Clear current session state and switch to create mode + for key in [ + "dialog_speakers", + "dialog_name", + "dialog_description", + "dialog_tts_provider", + "dialog_tts_model", + "dialog_loaded", + ]: + if key in st.session_state: + del st.session_state[key] + st.session_state.switch_to_create = True + st.rerun() + return + + # Show current episode info if available + if episode_context: + episode_profiles = fetch_episode_profiles() + current_episode = next( + (ep for ep in episode_profiles if ep["id"] == episode_context), None + ) + if current_episode: + st.info( + f"Configuring speaker for episode profile: **{current_episode.get('name', 'Unknown')}**" + ) + + # Speaker selection + speaker_names = [sp["name"] for sp in speaker_profiles] + current_speaker = None + current_idx = 0 + + # Try to get current speaker from episode if available + if episode_context: + episode_profiles = fetch_episode_profiles() + current_episode = next( + (ep for ep in episode_profiles if ep["id"] == episode_context), None + ) + if current_episode: + current_speaker = current_episode.get("speaker_config") + if current_speaker in speaker_names: + current_idx = speaker_names.index(current_speaker) + + selected_speaker = st.selectbox( + "Select Speaker Profile*", + speaker_names, + index=current_idx, + help="Choose an existing speaker profile or create a new one below", + ) + + # Show selected speaker details + if selected_speaker: + selected_profile = next( + (sp for sp in speaker_profiles if sp["name"] == selected_speaker), None + ) + if selected_profile: + with st.expander(f"🎤 Preview: {selected_speaker}", expanded=True): + st.write( + f"**Description:** {selected_profile.get('description', 'N/A')}" + ) + st.write( + f"**TTS:** {selected_profile.get('tts_provider', 'N/A')}/{selected_profile.get('tts_model', 'N/A')}" + ) + + speakers = selected_profile.get("speakers", []) + st.write(f"**Speakers ({len(speakers)}):**") + for i, speaker in enumerate(speakers, 1): + st.caption( + f"{i}. {speaker.get('name', 'Unknown')} - {speaker.get('voice_id', 'N/A')}" + ) + + # Action buttons + col1, col2, col3 = st.columns(3) + + with col1: + if st.button("✅ Assign Speaker", type="primary"): + if episode_context and selected_speaker: + # Update episode profile with selected speaker + episode_profiles = fetch_episode_profiles() + current_episode = next( + (ep for ep in episode_profiles if ep["id"] == episode_context), + None, + ) + if current_episode: + # Preserve all existing data, just update speaker_config + updated_data = { + "name": current_episode.get("name", ""), + "description": current_episode.get("description", ""), + "speaker_config": selected_speaker, + "outline_provider": current_episode.get( + "outline_provider", "" + ), + "outline_model": current_episode.get("outline_model", ""), + "transcript_provider": current_episode.get( + "transcript_provider", "" + ), + "transcript_model": current_episode.get( + "transcript_model", "" + ), + "default_briefing": current_episode.get( + "default_briefing", "" + ), + "num_segments": current_episode.get("num_segments", 5), + } + + success = update_episode_profile(episode_context, updated_data) + if success: + st.success( + f"Speaker '{selected_speaker}' assigned to episode!" + ) + st.rerun() + else: + st.error("Failed to assign speaker") + else: + st.error("Please select a speaker profile") + + with col2: + if st.button("➕ Create New Speaker"): + # Clear current session state and switch to create mode + for key in [ + "dialog_speakers", + "dialog_name", + "dialog_description", + "dialog_tts_provider", + "dialog_tts_model", + "dialog_loaded", + ]: + if key in st.session_state: + del st.session_state[key] + # Store episode context for later assignment + st.session_state.pending_episode_assignment = episode_context + st.session_state.switch_to_create = True + st.rerun() + + with col3: + if st.button("❌ Cancel"): + st.rerun() + + return + + # TTS Provider/Model selection outside form for reactivity + col1, col2 = st.columns(2) + with col1: + tts_provider = st.selectbox( + "TTS Provider*", list(tts_provider_models.keys()), key="dialog_tts_provider" + ) + + with col2: + tts_model = st.selectbox( + "TTS Model*", tts_provider_models[tts_provider], key="dialog_tts_model" + ) + + # Speakers configuration section using fragment + speaker_management_fragment() + + with st.form("speaker_config_dialog_form"): + col3, col4 = st.columns(2) + + with col3: + sp_name = st.text_input( + "Profile Name*", + value=st.session_state.get("dialog_name", ""), + placeholder="e.g., tech_experts", + ) + + with col4: + sp_description = st.text_area( + "Description", + value=st.session_state.get("dialog_description", ""), + placeholder="Brief description of this speaker configuration", + ) + + # Submit buttons + col7, col8 = st.columns(2) + with col7: + submit_label = "💾 Save Changes" if mode == "edit" else "✅ Create Profile" + if st.form_submit_button(submit_label): + # Validate speakers + valid_speakers = [] + for speaker in st.session_state.dialog_speakers: + if ( + speaker.get("name") + and speaker.get("voice_id") + and speaker.get("backstory") + and speaker.get("personality") + ): + valid_speakers.append(speaker) + + if sp_name and valid_speakers: + profile_data = { + "name": sp_name, + "description": sp_description, + "tts_provider": tts_provider, + "tts_model": tts_model, + "speakers": valid_speakers, + } + + if mode == "create": + success = create_speaker_profile(profile_data) + if success: + st.success("Speaker profile created successfully!") + + # Auto-assign to episode if created from episode context + pending_episode = st.session_state.get( + "pending_episode_assignment" + ) + if pending_episode: + episode_profiles = fetch_episode_profiles() + current_episode = next( + ( + ep + for ep in episode_profiles + if ep["id"] == pending_episode + ), + None, + ) + if current_episode: + # Update episode with new speaker + updated_data = { + "name": current_episode.get("name", ""), + "description": current_episode.get( + "description", "" + ), + "speaker_config": sp_name, # Assign the newly created speaker + "outline_provider": current_episode.get( + "outline_provider", "" + ), + "outline_model": current_episode.get( + "outline_model", "" + ), + "transcript_provider": current_episode.get( + "transcript_provider", "" + ), + "transcript_model": current_episode.get( + "transcript_model", "" + ), + "default_briefing": current_episode.get( + "default_briefing", "" + ), + "num_segments": current_episode.get( + "num_segments", 5 + ), + } + + assign_success = update_episode_profile( + pending_episode, updated_data + ) + if assign_success: + st.success( + f"Speaker '{sp_name}' automatically assigned to episode!" + ) + + # Clear pending assignment + del st.session_state.pending_episode_assignment + + # Clear session state + for key in [ + "dialog_speakers", + "dialog_name", + "dialog_description", + "dialog_tts_provider", + "dialog_tts_model", + "dialog_loaded", + ]: + if key in st.session_state: + del st.session_state[key] + st.rerun() + else: + st.error("Failed to create speaker profile") + elif mode == "edit": + success = update_speaker_profile(profile_id, profile_data) + if success: + st.success("Speaker profile updated successfully!") + # Clear session state + for key in [ + "dialog_speakers", + "dialog_name", + "dialog_description", + "dialog_tts_provider", + "dialog_tts_model", + "dialog_loaded", + ]: + if key in st.session_state: + del st.session_state[key] + st.rerun() + else: + st.error("Failed to update speaker profile") + else: + st.error( + "Please fill in all required fields (*) for at least one speaker" + ) + + with col8: + if st.form_submit_button("❌ Cancel"): + # Clear session state + for key in [ + "dialog_speakers", + "dialog_name", + "dialog_description", + "dialog_tts_provider", + "dialog_tts_model", + "dialog_loaded", + ]: + if key in st.session_state: + del st.session_state[key] + st.rerun() + + +def get_status_emoji(status: str) -> str: + """Get emoji for job status""" + status_map = { + "completed": "✅", + "running": "🔄", + "processing": "🔄", + "failed": "❌", + "error": "❌", + "pending": "⏳", + "submitted": "⏳", + } + return status_map.get(status, "❓") + + +def format_relative_time(created_str: str) -> str: + """Format creation time as relative time""" + try: + # Parse ISO format datetime + if created_str.endswith("Z"): + created_str = created_str[:-1] + "+00:00" + created = datetime.fromisoformat(created_str) + + # Simple relative time calculation + now = datetime.now(created.tzinfo) + diff = now - created + + if diff.days > 0: + return f"{diff.days} day{'s' if diff.days > 1 else ''} ago" + elif diff.seconds > 3600: + hours = diff.seconds // 3600 + return f"{hours} hour{'s' if hours > 1 else ''} ago" + elif diff.seconds > 60: + minutes = diff.seconds // 60 + return f"{minutes} minute{'s' if minutes > 1 else ''} ago" + else: + return "Just now" + except Exception: + return "Unknown" + + +def fetch_episodes(): + """Fetch episodes from API""" + try: + return podcast_api_service.get_episodes() + except Exception as e: + st.error(f"Error fetching episodes: {str(e)}") + return [] + + +def fetch_episode_profiles(): + """Fetch episode profiles from API""" + try: + return podcast_api_service.get_episode_profiles() + except Exception as e: + st.error(f"Error fetching episode profiles: {str(e)}") + return [] + + +def fetch_speaker_profiles(): + """Fetch speaker profiles from API""" + try: + return podcast_api_service.get_speaker_profiles() + except Exception as e: + st.error(f"Error fetching speaker profiles: {str(e)}") + return [] + + +def create_episode_profile(profile_data): + """Create new episode profile""" + return podcast_api_service.create_episode_profile(profile_data) + + +def update_episode_profile(profile_id, profile_data): + """Update episode profile""" + return podcast_api_service.update_episode_profile(profile_id, profile_data) + + +def delete_episode_profile(profile_id): + """Delete episode profile""" + return podcast_api_service.delete_episode_profile(profile_id) + + +def duplicate_episode_profile(profile_id): + """Duplicate episode profile""" + return podcast_api_service.duplicate_episode_profile(profile_id) + + +def create_speaker_profile(profile_data): + """Create new speaker profile""" + return podcast_api_service.create_speaker_profile(profile_data) + + +def update_speaker_profile(profile_id, profile_data): + """Update speaker profile""" + return podcast_api_service.update_speaker_profile(profile_id, profile_data) + + +def delete_speaker_profile(profile_id): + """Delete speaker profile""" + return podcast_api_service.delete_speaker_profile(profile_id) + + +def duplicate_speaker_profile(profile_id): + """Duplicate speaker profile""" + return podcast_api_service.duplicate_speaker_profile(profile_id) + + +def delete_episode(episode_id): + """Delete podcast episode and its audio file""" + return podcast_api_service.delete_episode(episode_id) + + +def analyze_speaker_usage(speakers, episodes): + """Analyze which speaker profiles are used by episode profiles""" + usage_map = {} + for speaker in speakers: + speaker_name = speaker.get("name", "") + usage_map[speaker_name] = 0 + + for episode in episodes: + speaker_config = episode.get("speaker_config", "") + if speaker_config in usage_map: + usage_map[speaker_config] += 1 + + return usage_map + + +def render_speaker_info_inline(speaker_config, speaker_profiles): + """Render speaker information inline within episode profile cards""" + if not speaker_config: + st.warning("⚠️ No speaker profile assigned") + return + + # Find the matching speaker profile + speaker_profile = None + for profile in speaker_profiles: + if profile.get("name") == speaker_config: + speaker_profile = profile + break + + if not speaker_profile: + st.error(f"❌ Speaker profile '{speaker_config}' not found") + return + + # Display speaker info + st.write(f"**🎤 Speaker Profile:** {speaker_config}") + st.write( + f"**TTS:** {speaker_profile.get('tts_provider', 'N/A')}/{speaker_profile.get('tts_model', 'N/A')}" + ) + + speakers = speaker_profile.get("speakers", []) + if speakers: + st.write(f"**Speakers ({len(speakers)}):**") + for i, speaker in enumerate(speakers, 1): + st.caption( + f"{i}. {speaker.get('name', 'Unknown')} - {speaker.get('voice_id', 'N/A')}" + ) + + +def render_episode_profiles_section(): + """Render episode profiles in the main area""" + st.subheader("📺 Episode Profiles") + + # Fetch data + episode_profiles = fetch_episode_profiles() + speaker_profiles = fetch_speaker_profiles() + + # Create new episode profile section + with st.expander("➕ Create New Episode Profile", expanded=False): + # AI Model Configuration outside form for reactivity + st.subheader("🤖 AI Model Configuration") + col_ai1, col_ai2 = st.columns(2) + + with col_ai1: + outline_provider = st.selectbox( + "Outline Provider*", + list(transcript_provider_models.keys()), + key="new_outline_provider", + ) + outline_model = st.selectbox( + "Outline Model*", + transcript_provider_models[outline_provider], + key="new_outline_model", + ) + + with col_ai2: + transcript_provider = st.selectbox( + "Transcript Provider*", + list(transcript_provider_models.keys()), + key="new_transcript_provider", + ) + transcript_model = st.selectbox( + "Transcript Model*", + transcript_provider_models[transcript_provider], + key="new_transcript_model", + ) + + with st.form("create_episode_profile"): + col1, col2 = st.columns(2) + + with col1: + ep_name = st.text_input( + "Profile Name*", placeholder="e.g., tech_discussion" + ) + ep_description = st.text_area( + "Description", placeholder="Brief description of this profile" + ) + ep_segments = st.number_input( + "Number of Segments", min_value=3, max_value=20, value=5 + ) + + with col2: + # Speaker config dropdown + speaker_names = ( + [sp["name"] for sp in speaker_profiles] if speaker_profiles else [] + ) + + if speaker_names: + ep_speaker_config = st.selectbox( + "Speaker Configuration*", speaker_names + ) + else: + st.warning( + "No speaker profiles available. Create a speaker profile first." + ) + ep_speaker_config = None + + # Default briefing + ep_briefing = st.text_area( + "Default Briefing*", + placeholder="Enter the default briefing template for this episode type...", + height=150, + ) + + submitted = st.form_submit_button("Create Episode Profile") + + if submitted: + if ep_name and ep_speaker_config and ep_briefing: + success = create_episode_profile( + { + "name": ep_name, + "description": ep_description, + "speaker_config": ep_speaker_config, + "outline_provider": outline_provider, + "outline_model": outline_model, + "transcript_provider": transcript_provider, + "transcript_model": transcript_model, + "default_briefing": ep_briefing, + "num_segments": ep_segments, + } + ) + if success: + st.success("Episode profile created successfully!") + st.rerun() + else: + st.error("Failed to create episode profile") + else: + st.error("Please fill in all required fields (*)") + + # Display existing episode profiles + if episode_profiles: + st.write(f"**{len(episode_profiles)} Episode Profile(s):**") + + for profile in episode_profiles: + with st.container(border=True): + col_info, col_actions = st.columns([3, 1]) + + with col_info: + st.subheader(profile.get("name", "Unknown")) + st.write(f"**Description:** {profile.get('description', 'N/A')}") + st.write(f"**Segments:** {profile.get('num_segments', 'N/A')}") + st.write( + f"**Outline Model:** {profile.get('outline_provider', 'N/A')}/{profile.get('outline_model', 'N/A')}" + ) + st.write( + f"**Transcript Model:** {profile.get('transcript_provider', 'N/A')}/{profile.get('transcript_model', 'N/A')}" + ) + + # Inline speaker information + st.divider() + render_speaker_info_inline( + profile.get("speaker_config"), speaker_profiles + ) + + with col_actions: + if st.button( + "⚙️ Configure Speaker", + key=f"config_speaker_{profile['id']}", + help="Configure speaker profile", + ): + speaker_configuration_dialog( + "select", episode_context=profile["id"] + ) + + if st.button("✏️ Edit", key=f"edit_ep_{profile['id']}"): + st.session_state[f"edit_episode_{profile['id']}"] = True + st.rerun() + + if st.button("📋 Duplicate", key=f"dup_ep_{profile['id']}"): + success = duplicate_episode_profile(profile["id"]) + if success: + st.success("Profile duplicated!") + st.rerun() + + if st.button("🗑️ Delete", key=f"del_ep_{profile['id']}"): + confirm_delete_episode_profile(profile["id"], profile["name"]) + + # Show briefing + st.text_area( + "Default Briefing:", + value=profile.get("default_briefing", ""), + height=100, + disabled=True, + key=f"briefing_display_{profile['id']}", + ) + + # Edit form (if in edit mode) + if st.session_state.get(f"edit_episode_{profile['id']}", False): + st.subheader("✏️ Edit Episode Profile") + + # AI models outside form for reactivity + col5, col6 = st.columns(2) + with col5: + current_outline_provider = profile.get( + "outline_provider", + list(transcript_provider_models.keys())[0], + ) + outline_idx = ( + list(transcript_provider_models.keys()).index( + current_outline_provider + ) + if current_outline_provider in transcript_provider_models + else 0 + ) + edit_outline_provider = st.selectbox( + "Outline Provider", + list(transcript_provider_models.keys()), + index=outline_idx, + key=f"edit_outline_provider_{profile['id']}", + ) + + current_outline_model = profile.get("outline_model", "") + outline_model_idx = 0 + if ( + current_outline_model + in transcript_provider_models[edit_outline_provider] + ): + outline_model_idx = transcript_provider_models[ + edit_outline_provider + ].index(current_outline_model) + edit_outline_model = st.selectbox( + "Outline Model", + transcript_provider_models[edit_outline_provider], + index=outline_model_idx, + key=f"edit_outline_model_{profile['id']}", + ) + + with col6: + current_transcript_provider = profile.get( + "transcript_provider", + list(transcript_provider_models.keys())[0], + ) + transcript_idx = ( + list(transcript_provider_models.keys()).index( + current_transcript_provider + ) + if current_transcript_provider in transcript_provider_models + else 0 + ) + edit_transcript_provider = st.selectbox( + "Transcript Provider", + list(transcript_provider_models.keys()), + index=transcript_idx, + key=f"edit_transcript_provider_{profile['id']}", + ) + + current_transcript_model = profile.get("transcript_model", "") + transcript_model_idx = 0 + if ( + current_transcript_model + in transcript_provider_models[edit_transcript_provider] + ): + transcript_model_idx = transcript_provider_models[ + edit_transcript_provider + ].index(current_transcript_model) + edit_transcript_model = st.selectbox( + "Transcript Model", + transcript_provider_models[edit_transcript_provider], + index=transcript_model_idx, + key=f"edit_transcript_model_{profile['id']}", + ) + + with st.form(f"edit_episode_form_{profile['id']}"): + # Form fields with current values + edit_name = st.text_input( + "Profile Name", value=profile.get("name", "") + ) + edit_description = st.text_area( + "Description", value=profile.get("description", "") + ) + edit_segments = st.number_input( + "Segments", + min_value=3, + max_value=20, + value=profile.get("num_segments", 5), + ) + + # Speaker config + speaker_names = ( + [sp["name"] for sp in speaker_profiles] + if speaker_profiles + else [] + ) + current_speaker = profile.get("speaker_config", "") + speaker_idx = ( + speaker_names.index(current_speaker) + if current_speaker in speaker_names + else 0 + ) + edit_speaker_config = st.selectbox( + "Speaker Configuration", speaker_names, index=speaker_idx + ) + + edit_briefing = st.text_area( + "Default Briefing", + value=profile.get("default_briefing", ""), + height=150, + ) + + col7, col8 = st.columns(2) + with col7: + if st.form_submit_button("💾 Save Changes"): + success = update_episode_profile( + profile["id"], + { + "name": edit_name, + "description": edit_description, + "speaker_config": edit_speaker_config, + "outline_provider": edit_outline_provider, + "outline_model": edit_outline_model, + "transcript_provider": edit_transcript_provider, + "transcript_model": edit_transcript_model, + "default_briefing": edit_briefing, + "num_segments": edit_segments, + }, + ) + if success: + st.success("Profile updated!") + st.session_state[ + f"edit_episode_{profile['id']}" + ] = False + st.rerun() + + with col8: + if st.form_submit_button("❌ Cancel"): + st.session_state[f"edit_episode_{profile['id']}"] = ( + False + ) + st.rerun() + else: + st.info("No episode profiles found. Create your first episode profile above.") + + +def render_speaker_profiles_sidebar(): + """Render speaker profiles in the sidebar with usage indicators""" + st.subheader("🎤 Speaker Profiles") + + # New Speaker Profile button + if st.button("➕ New Speaker Profile", use_container_width=True): + speaker_configuration_dialog("create") + + # Fetch speaker profiles and episode profiles for usage analysis + speaker_profiles = fetch_speaker_profiles() + episode_profiles = fetch_episode_profiles() + + if not speaker_profiles: + st.info("No speaker profiles found. Create your first speaker profile above.") + return + + # Analyze usage + usage_map = analyze_speaker_usage(speaker_profiles, episode_profiles) + + st.write(f"**{len(speaker_profiles)} Speaker Profile(s):**") + + for profile in speaker_profiles: + profile_name = profile.get("name", "Unknown") + usage_count = usage_map.get(profile_name, 0) + + # Usage indicator + if usage_count > 0: + usage_indicator = f"✅ Used ({usage_count})" + else: + usage_indicator = "⭕ Unused" + + with st.expander(f"🎤 {profile_name} {usage_indicator}", expanded=False): + # Speaker profile summary + st.write(profile.get("description", "N/A")) + st.caption( + f"**TTS:** {profile.get('tts_provider', 'N/A')}/{profile.get('tts_model', 'N/A')}" + ) + + speakers = profile.get("speakers", []) + # st.write(f"**Speakers:** {len(speakers)}") + for i, speaker in enumerate(speakers): # Show first 2 speakers only + st.markdown( + f"- {speaker.get('name', 'Unknown')} ({speaker.get('voice_id', 'N/A')})\n" + ) + # if len(speakers) > 2: + # st.caption(f"... and {len(speakers) - 2} more") + + # Action buttons + col1, col2, col3 = st.columns(3) + with col1: + if st.button("✏️", key=f"edit_sp_sidebar_{profile['id']}", help="Edit"): + speaker_configuration_dialog("edit", profile["id"]) + with col2: + if st.button( + "📋", key=f"dup_sp_sidebar_{profile['id']}", help="Duplicate" + ): + success = duplicate_speaker_profile(profile["id"]) + if success: + st.success("Profile duplicated!") + st.rerun() + with col3: + if st.button("🗑️", key=f"del_sp_sidebar_{profile['id']}", help="Delete"): + confirm_delete_speaker_profile(profile["id"], profile["name"]) + + +# Main page title +st.title("🎙️ Podcast Generator") +st.markdown("Manage your podcast episodes and configurations") + +# Create tabs +episodes_tab, templates_tab = st.tabs(["Episodes", "Templates"]) + +with episodes_tab: + st.header("📻 Episodes") + + existing_episodes = asyncio.run( + repo_query("select count() from podcast_episode group all") + ) + existing_episodes_count = existing_episodes[0]["count"] + if existing_episodes_count > 0: + st.warning( + f"**Please Decide:** Found {existing_episodes_count} episode(s) from the old podcast implementation." + ) + c1, c2 = st.columns(2) + if c1.button("Migrate them"): + asyncio.run( + repo_query( + "INSERT into episode (select audio_file, created, instructions as briefing, text as content, {} as episode_profile, {} as speaker_profile, name from podcast_episode);" + ) + ) + asyncio.run(repo_query("DELETE from podcast_episode;")) + st.rerun() + if c2.button("Delete them"): + asyncio.run(repo_query("DELETE from podcast_episode;")) + st.rerun() + st.divider() + # Refresh button + col1, col2 = st.columns([1, 4]) + with col1: + if st.button("🔄 Refresh", help="Refresh episode status"): + st.rerun() + + # Fetch and display episodes + episodes = fetch_episodes() + + if not episodes: + st.info("No episodes found. Generate your first episode in the chat interface!") + else: + st.write(f"Found {len(episodes)} episode(s)") + + # Group episodes by status + status_groups = {"running": [], "completed": [], "failed": [], "pending": []} + + for episode in episodes: + status = episode.get("job_status", "unknown") + if status in ["running", "processing"]: + status_groups["running"].append(episode) + elif status == "completed": + status_groups["completed"].append(episode) + elif status in ["failed", "error"]: + status_groups["failed"].append(episode) + else: + status_groups["pending"].append(episode) + + # Display running episodes first + if status_groups["running"]: + st.subheader("🔄 Currently Processing") + for episode in status_groups["running"]: + with st.container(border=True): + col1, col2, col3 = st.columns([3, 1, 1]) + + with col1: + st.markdown(f"**{episode['name']}**") + st.caption( + f"Profile: {episode['episode_profile'].get('name', 'Unknown')}" + ) + + with col2: + if episode.get("created"): + st.caption( + f"Started: {format_relative_time(episode['created'])}" + ) + + with col3: + st.markdown( + f"{get_status_emoji(episode.get('job_status', 'unknown'))} Processing..." + ) + + # Display completed episodes + if status_groups["completed"]: + st.subheader("✅ Completed Episodes") + for episode in status_groups["completed"]: + with st.container(border=True): + col1, col2, col3 = st.columns([3, 1, 1]) + + with col1: + st.markdown(f"**{episode['name']}**") + st.caption( + f"Profile: {episode['episode_profile'].get('name', 'Unknown')}" + ) + if episode.get("created"): + st.caption( + f"Created: {format_relative_time(episode['created'])}" + ) + + with col2: + st.markdown(f"{get_status_emoji('completed')} Complete") + + with col3: + if st.button( + "🗑️ Delete", + key=f"del_episode_{episode['id']}", + help="Delete episode and audio file", + ): + confirm_delete_episode(episode["id"], episode["name"]) + + # Audio player + if episode.get("audio_file"): + try: + st.audio(episode["audio_file"], format="audio/mpeg") + except Exception as e: + st.error(f"Could not load audio: {str(e)}") + + # Episode details in separate expanders + with st.expander(f"🎭 Profiles - {episode['name']}", expanded=False): + if episode.get("briefing"): + st.text_area( + "Briefing Used:", + value=episode["briefing"], + height=100, + disabled=True, + key=f"briefing_{episode['id']}", + ) + + # Show episode profile info + if episode.get("episode_profile"): + st.subheader("📺 Episode Profile") + ep_profile = episode["episode_profile"] + st.write(f"**Name:** {ep_profile.get('name', 'Unknown')}") + st.write( + f"**Description:** {ep_profile.get('description', 'N/A')}" + ) + st.write( + f"**Segments:** {ep_profile.get('num_segments', 'N/A')}" + ) + st.write( + f"**Outline Model:** {ep_profile.get('outline_provider', 'N/A')}/{ep_profile.get('outline_model', 'N/A')}" + ) + st.write( + f"**Transcript Model:** {ep_profile.get('transcript_provider', 'N/A')}/{ep_profile.get('transcript_model', 'N/A')}" + ) + + # Show speaker configuration + if episode.get("speaker_profile"): + st.subheader("🎤 Speaker Profile") + sp_profile = episode["speaker_profile"] + st.write(f"**Name:** {sp_profile.get('name', 'Unknown')}") + st.write( + f"**Description:** {sp_profile.get('description', 'N/A')}" + ) + st.write( + f"**TTS Provider:** {sp_profile.get('tts_provider', 'N/A')}/{sp_profile.get('tts_model', 'N/A')}" + ) + + speakers = sp_profile.get("speakers", []) + st.write(f"**Speakers ({len(speakers)}):**") + for i, speaker in enumerate(speakers, 1): + st.markdown(f"**{i}. {speaker.get('name', 'Unknown')}**") + st.write( + f" - Voice: {speaker.get('voice_id', 'Unknown')}" + ) + st.write( + f" - Personality: {speaker.get('personality', 'N/A')}" + ) + if speaker.get("backstory"): + st.write(f" - Background: {speaker['backstory']}") + + # Show transcript if available + if episode.get("transcript"): + with st.expander( + f"📄 Transcript - {episode['name']}", expanded=False + ): + transcript_data = episode["transcript"] + if ( + isinstance(transcript_data, dict) + and "transcript" in transcript_data + ): + st.json(transcript_data["transcript"]) + else: + st.json(transcript_data) + + # Show outline if available + if episode.get("outline"): + with st.expander( + f"📋 Outline - {episode['name']}", expanded=False + ): + st.json(episode["outline"]) + + # Display failed episodes + if status_groups["failed"]: + st.subheader("❌ Failed Episodes") + for episode in status_groups["failed"]: + with st.container(border=True): + col1, col2 = st.columns([3, 1]) + + with col1: + st.markdown(f"**{episode['name']}**") + st.caption( + f"Profile: {episode['episode_profile'].get('name', 'Unknown')}" + ) + if episode.get("created"): + st.caption( + f"Created: {format_relative_time(episode['created'])}" + ) + + with col2: + st.markdown(f"{get_status_emoji('failed')} Failed") + + # Show error information + st.error( + "Episode generation failed. Check the logs for more details." + ) + + # Display pending episodes + if status_groups["pending"]: + st.subheader("⏳ Pending Episodes") + for episode in status_groups["pending"]: + with st.container(border=True): + col1, col2 = st.columns([3, 1]) + + with col1: + st.markdown(f"**{episode['name']}**") + st.caption( + f"Profile: {episode['episode_profile'].get('name', 'Unknown')}" + ) + if episode.get("created"): + st.caption( + f"Created: {format_relative_time(episode['created'])}" + ) + + with col2: + st.markdown(f"{get_status_emoji('pending')} Pending") + +# Get available providers and models using API service + +# Load available models +text_to_speech_models = models_service.get_all_models(model_type="text_to_speech") +text_models = models_service.get_all_models(model_type="language") + +# Build provider-model mappings +tts_provider_models = {} for model in text_to_speech_models: - if model.provider not in provider_models: - provider_models[model.provider] = [] - provider_models[model.provider].append(model.name) - -text_models = Model.get_models_by_type("language") - -transcript_provider_models: Dict[str, List[str]] = {} + if model.provider not in tts_provider_models: + tts_provider_models[model.provider] = [] + tts_provider_models[model.provider].append(model.name) +transcript_provider_models = {} for model in text_models: - if model.provider not in ["gemini", "openai", "anthropic"]: - continue if model.provider not in transcript_provider_models: transcript_provider_models[model.provider] = [] transcript_provider_models[model.provider].append(model.name) - +# Check if we have required models if len(text_to_speech_models) == 0: - st.error("No text to speech models found. Please set one up in the Models page.") + st.error("No text-to-speech models found. Please set one up in the Models page.") st.stop() if len(text_models) == 0: - st.error( - "No language models found. Please set one up in the Models page. Only Gemini, Open AI and Anthropic models supported for transcript generation." - ) + st.error("No language models found. Please set one up in the Models page.") st.stop() -episodes_tab, templates_tab = st.tabs(["Episodes", "Templates"]) - -with episodes_tab: - episodes = PodcastEpisode.get_all(order_by="created desc") - for episode in episodes: - with st.container(border=True): - episode_name = episode.name if episode.name else "No Name" - st.markdown(f"**{episode.template} - {episode_name}**") - # st.caption(naturaltime(episode.created)) - st.write(f"Instructions: {episode.instructions}") - try: - st.audio(episode.audio_file, format="audio/mpeg", loop=True) - except Exception as e: - st.write("No audio file found") - st.error(e) - with st.expander("Source Content"): - st.code(episode.text) - if st.button("Delete Episode", key=f"btn_delete{episode.id}"): - episode.delete() - st.rerun() - if len(episodes) == 0: - st.write("No episodes yet") with templates_tab: - st.subheader("Podcast Templates") - st.markdown("") - with st.expander("**Create new Template**"): - pd_cfg = {} - pd_cfg["name"] = st.text_input("Template Name") - pd_cfg["podcast_name"] = st.text_input("Podcast Name") - pd_cfg["podcast_tagline"] = st.text_input("Podcast Tagline") - pd_cfg["output_language"] = st.text_input("Language", value="English") - pd_cfg["user_instructions"] = st.text_input( - "User Instructions", - help="Any additional intructions to pass to the LLM that will generate the transcript", - ) - pd_cfg["person1_role"] = st_tags( - [], participant_roles, "Person 1 roles", key="person1_roles" - ) - st.caption(f"Suggestions:{', '.join(participant_roles)}") - pd_cfg["person2_role"] = st_tags( - [], participant_roles, "Person 2 roles", key="person2_roles" - ) - pd_cfg["conversation_style"] = st_tags( - [], conversation_styles, "Conversation Style", key="conversation_styles" - ) - st.caption(f"Suggestions:{', '.join(conversation_styles)}") - pd_cfg["engagement_technique"] = st_tags( - [], - engagement_techniques, - "Engagement Techniques", - key="engagement_techniques", - ) - st.caption(f"Suggestions:{', '.join(engagement_techniques)}") - pd_cfg["dialogue_structure"] = st_tags( - [], dialogue_structures, "Dialogue Structure", key="dialogue_structures" - ) - st.caption(f"Suggestions:{', '.join(dialogue_structures)}") - pd_cfg["creativity"] = st.slider( - "Creativity", min_value=0.0, max_value=1.0, step=0.05 - ) - pd_cfg["ending_message"] = st.text_input( - "Ending Message", placeholder="Thank you for listening!" - ) - pd_cfg["transcript_model_provider"] = st.selectbox( - "Transcript Model Provider", transcript_provider_models.keys() - ) - pd_cfg["transcript_model"] = st.selectbox( - "Transcript Model", - transcript_provider_models[pd_cfg["transcript_model_provider"]], - ) + # Header section with explanatory content + st.header("📺 Episode Templates") - pd_cfg["provider"] = st.selectbox( - "Audio Model Provider", provider_models.keys() + # Explanatory header about relationships and workflow + st.markdown(""" + #### Understanding Episode Profiles and Speaker Profiles + + **Episode profiles** define the format and AI models for podcast generation, including: + - Number of segments, outline and transcript AI models + - Default briefing templates + + **Speaker profiles** define the voices and personalities that will be used, including: + - TTS provider and model settings + - Individual speaker configurations (name, voice ID, personality, backstory) + + **Important**: Episode profiles reference speaker profiles by name. You can either: + 1. **Recommended workflow**: Create speaker profiles first, then create episode profiles that use them + 2. **Alternative**: Create episode profiles and add speaker profiles on-demand via configuration dialogs (coming in later phases) + """) + + st.divider() + + old_profiles = asyncio.run(repo_query("select * from podcast_config")) + if old_profiles: + st.warning( + "Found old podcast profiles. You will need to recreate them on the new configuration format. They won't be migrated automatically. You can copy what you need from here and delete them when you are done." ) - pd_cfg["model"] = st.selectbox( - "Audio Model", provider_models[pd_cfg["provider"]] + with st.expander("Old Profiles"): + st.json(old_profiles) + st.write( + "When you are done creating your new profiles, you can safely delete the old ones" ) - st.caption( - "OpenAI: tts-1 or tts-1-hd, Elevenlabs: eleven_multilingual_v2, eleven_turbo_v2_5" - ) - pd_cfg["voice1"] = st.text_input( - "Voice 1", help="You can use Elevenlabs voice ID" - ) - st.caption("Voice names are case sensitive. Be sure to add the exact name.") + if st.button("Delete old profiles"): + asyncio.run(repo_query("delete from podcast_config")) + st.success("Old profiles deleted!") + st.rerun() + st.divider() + # Main layout: Episode profiles (main area) + Speaker profiles (sidebar) + col_main, col_sidebar = st.columns([3, 1]) - st.markdown( - "Sample voices from: [Open AI](https://platform.openai.com/docs/guides/text-to-speech), [Gemini](https://cloud.google.com/text-to-speech/docs/voices), [Elevenlabs](https://elevenlabs.io/text-to-speech)" - ) + with col_main: + render_episode_profiles_section() - pd_cfg["voice2"] = st.text_input( - "Voice 2", help="You can use Elevenlabs voice ID" - ) - - if st.button("Save"): - try: - pd = PodcastConfig(**pd_cfg) - pd_cfg = {} - pd.save() - except Exception as e: - st.error(e) - - for pd_config in PodcastConfig.get_all(order_by="created desc"): - with st.expander(pd_config.name): - pd_config.name = st.text_input( - "Template Name", value=pd_config.name, key=f"name_{pd_config.id}" - ) - pd_config.podcast_name = st.text_input( - "Podcast Name", - value=pd_config.podcast_name, - key=f"podcast_name_{pd_config.id}", - ) - pd_config.podcast_tagline = st.text_input( - "Podcast Tagline", - value=pd_config.podcast_tagline, - key=f"podcast_tagline_{pd_config.id}", - ) - pd_config.user_instructions = st.text_input( - "User Instructions", - value=pd_config.user_instructions, - help="Any additional intructions to pass to the LLM that will generate the transcript", - key=f"user_instructions_{pd_config.id}", - ) - - pd_config.output_language = st.text_input( - "Language", - value=pd_config.output_language, - key=f"output_language_{pd_config.id}", - ) - pd_config.person1_role = st_tags( - pd_config.person1_role, - conversation_styles, - "Person 1 Roles", - key=f"person_1_roles_{pd_config.id}", - ) - st.caption(f"Suggestions:{', '.join(participant_roles)}") - pd_config.person2_role = st_tags( - pd_config.person2_role, - conversation_styles, - "Person 2 Roles", - key=f"person_2_roles_{pd_config.id}", - ) - - pd_config.conversation_style = st_tags( - pd_config.conversation_style, - conversation_styles, - "Conversation Style", - key=f"conversation_style_{pd_config.id}", - ) - st.caption(f"Suggestions:{', '.join(conversation_styles)}") - pd_config.engagement_technique = st_tags( - pd_config.engagement_technique, - engagement_techniques, - "Engagement Techniques", - key=f"engagement_technique_{pd_config.id}", - ) - st.caption(f"Suggestions:{', '.join(engagement_techniques)}") - pd_config.dialogue_structure = st_tags( - pd_config.dialogue_structure, - dialogue_structures, - "Dialogue Structure", - key=f"dialogue_structure_{pd_config.id}", - ) - st.caption(f"Suggestions:{', '.join(dialogue_structures)}") - pd_config.creativity = st.slider( - "Creativity", - min_value=0.0, - max_value=1.0, - step=0.05, - value=pd_config.creativity, - key=f"creativity_{pd_config.id}", - ) - pd_config.ending_message = st.text_input( - "Ending Message", - value=pd_config.ending_message, - placeholder="Thank you for listening!", - key=f"ending_message_{pd_config.id}", - ) - - if pd_config.transcript_model_provider not in transcript_provider_models: - index = 0 - else: - index = list(transcript_provider_models.keys()).index( - pd_config.transcript_model_provider - ) - - pd_config.transcript_model_provider = st.selectbox( - "Transcript Model Provider", - list(transcript_provider_models.keys()), - index=index, - key=f"transcript_provider_{pd_config.id}", - ) - if ( - not pd_config.transcript_model - or pd_config.transcript_model - not in transcript_provider_models[pd_config.transcript_model_provider] - ): - index = 0 - else: - index = transcript_provider_models[ - pd_config.transcript_model_provider - ].index(pd_config.transcript_model) - pd_config.transcript_model = st.selectbox( - "Transcript Model", - transcript_provider_models[pd_config.transcript_model_provider], - index=index, - key=f"transcript_model_{pd_config.id}", - ) - - # Cleanup provider_models to only include specified providers - # filtered_provider_models = { - # k: v - # for k, v in provider_models.items() - # if k in ["openai", "vertex", "elevenlabs"] - # } - # provider_models = filtered_provider_models - - pd_config.provider = st.selectbox( - "Audio Model Provider", - list(provider_models.keys()), - index=list(provider_models.keys()).index(pd_config.provider), - key=f"provider_{pd_config.id}", - ) - if pd_config.model not in provider_models[pd_config.provider]: - index = 0 - else: - index = provider_models[pd_config.provider].index(pd_config.model) - pd_config.model = st.selectbox( - "Model", - provider_models[pd_config.provider], - index=index, - key=f"model_{pd_config.id}", - ) - pd_config.voice1 = st.text_input( - "Voice 1", - value=pd_config.voice1, - key=f"voice1_{pd_config.id}", - help="You can use Elevenlabs voice ID", - ) - st.caption("Voice names are case sensitive. Be sure to add the exact name.") - st.markdown( - "Sample voices from: [Open AI](https://platform.openai.com/docs/guides/text-to-speech), [Elevenlabs](https://elevenlabs.io/text-to-speech), [Gemini](https://ai.google.dev/gemini-api/docs/speech-generation), [Vertex AI](https://cloud.google.com/text-to-speech/docs/list-voices-and-types)" - ) - - pd_config.voice2 = st.text_input( - "Voice 2", - value=pd_config.voice2, - key=f"voice2_{pd_config.id}", - help="You can use Elevenlabs voice ID", - ) - - if st.button("Save Config", key=f"btn_save{pd_config.id}"): - try: - pd_config.save() - st.toast("Podcast template saved") - except Exception as e: - st.error(e) - - if st.button("Duplicate Config", key=f"btn_duplicate{pd_config.id}"): - pd_config.name = f"{pd_config.name} - Copy" - pd_config.id = None - pd_config.save() - st.rerun() - - if st.button("Delete Config", key=f"btn_delete{pd_config.id}"): - pd_config.delete() - st.rerun() + with col_sidebar: + render_speaker_profiles_sidebar() diff --git a/pages/7_🤖_Models.py b/pages/7_🤖_Models.py index 1641981..f04f3f8 100644 --- a/pages/7_🤖_Models.py +++ b/pages/7_🤖_Models.py @@ -1,13 +1,17 @@ import os +import nest_asyncio + +nest_asyncio.apply() + import streamlit as st from esperanto import AIFactory -from open_notebook.domain.models import DefaultModels, Model, model_manager +from api.models_service import models_service from pages.components.model_selector import model_selector from pages.stream_app.utils import setup_page -setup_page("🤖 Models", only_check_mandatory_models=False, stop_on_model_error=False) +setup_page("🤖 Models", only_check_mandatory_models=False, stop_on_model_error=False, skip_model_check=True) st.title("🤖 Models") @@ -33,7 +37,10 @@ def check_available_providers(): and os.environ.get("VERTEX_LOCATION") is not None and os.environ.get("GOOGLE_APPLICATION_CREDENTIALS") is not None ) - provider_status["gemini"] = os.environ.get("GOOGLE_API_KEY") is not None + provider_status["gemini"] = ( + os.environ.get("GOOGLE_API_KEY") is not None + or os.environ.get("GEMINI_API_KEY") is not None + ) provider_status["openrouter"] = ( os.environ.get("OPENROUTER_API_KEY") is not None and os.environ.get("OPENAI_API_KEY") is not None @@ -41,7 +48,7 @@ def check_available_providers(): ) provider_status["anthropic"] = os.environ.get("ANTHROPIC_API_KEY") is not None provider_status["elevenlabs"] = os.environ.get("ELEVENLABS_API_KEY") is not None - provider_status["voyage"] = os.environ.get("VORAGE_API_KEY") is not None + provider_status["voyage"] = os.environ.get("VOYAGE_API_KEY") is not None provider_status["azure"] = ( os.environ.get("AZURE_OPENAI_API_KEY") is not None and os.environ.get("AZURE_OPENAI_ENDPOINT") is not None @@ -57,8 +64,8 @@ def check_available_providers(): return available_providers, unavailable_providers -default_models = DefaultModels() -all_models = Model.get_all() +default_models = models_service.get_default_models() +all_models = models_service.get_all_models() esperanto_available_providers = AIFactory.get_available_providers() @@ -76,8 +83,11 @@ st.divider() # Helper function to add model with auto-save -def add_model_form(model_type, container_key): - available_providers = esperanto_available_providers.get(model_type, []) +def add_model_form(model_type, container_key, configured_providers): + # Get providers that Esperanto supports for this model type + esperanto_providers = esperanto_available_providers.get(model_type, []) + # Filter to only show providers that have API keys configured + available_providers = [p for p in esperanto_providers if p in configured_providers] # Sort providers alphabetically for easier navigation available_providers.sort() @@ -106,8 +116,9 @@ def add_model_form(model_type, container_key): if st.form_submit_button("Add Model"): if model_name: - model = Model(name=model_name, provider=provider, type=model_type) - model.save() + models_service.create_model( + name=model_name, provider=provider, model_type=model_type + ) st.success("Model added!") st.rerun() @@ -126,13 +137,13 @@ def handle_default_selection( # Auto-save when selection changes if selected_model and (not current_value or selected_model.id != current_value): setattr(default_models, key, selected_model.id) - default_models.update() - model_manager.refresh_defaults() + models_service.update_default_models(default_models) + # Model defaults are automatically refreshed through the API service st.toast(f"Default {model_type} model set to {selected_model.name}") elif not selected_model and current_value: setattr(default_models, key, None) - default_models.update() - model_manager.refresh_defaults() + models_service.update_default_models(default_models) + # Model defaults are automatically refreshed through the API service st.toast(f"Default {model_type} model removed") if caption: @@ -175,13 +186,13 @@ with st.container(border=True): if st.button( "🗑️", key=f"delete_lang_{model.id}", help="Delete model" ): - model.delete() + models_service.delete_model(model.id) st.rerun() else: st.info("No language models configured") with col2: - add_model_form("language", "main") + add_model_form("language", "main", available_providers) st.markdown("**Default Model Assignments**") col1, col2 = st.columns(2) @@ -223,6 +234,12 @@ with st.container(border=True): "language", "Recommended: Gemini models", ) + + # Show warning if mandatory language models are missing + if not default_models.default_chat_model or not default_models.default_transformation_model: + st.warning("⚠️ Please select a Chat Model and Transformation Model - these are required for Open Notebook to function properly.") + elif not default_models.default_tools_model: + st.info("💡 Consider selecting a Tools Model for better tool calling capabilities (recommended: OpenAI or Anthropic models).") # Embedding Models Section st.subheader("🔍 Embedding Models") @@ -241,7 +258,7 @@ with st.container(border=True): if st.button( "🗑️", key=f"delete_emb_{model.id}", help="Delete model" ): - model.delete() + models_service.delete_model(model.id) st.rerun() else: st.info("No embedding models configured") @@ -254,9 +271,13 @@ with st.container(border=True): "embedding", ) st.warning("⚠️ Changing embedding models requires regenerating all embeddings") + + # Show warning if no default embedding model is selected + if not default_models.default_embedding_model: + st.warning("⚠️ Please select a default Embedding Model - this is required for search functionality.") with col2: - add_model_form("embedding", "main") + add_model_form("embedding", "main", available_providers) # Text-to-Speech Models Section st.subheader("🎙️ Text-to-Speech Models") @@ -275,7 +296,7 @@ with st.container(border=True): if st.button( "🗑️", key=f"delete_tts_{model.id}", help="Delete model" ): - model.delete() + models_service.delete_model(model.id) st.rerun() else: st.info("No text-to-speech models configured") @@ -288,9 +309,13 @@ with st.container(border=True): "text_to_speech", "Can be overridden per podcast", ) + + # Show info if no default TTS model is selected + if not default_models.default_text_to_speech_model: + st.info("ℹ️ Select a default TTS model to enable podcast generation.") with col2: - add_model_form("text_to_speech", "main") + add_model_form("text_to_speech", "main", available_providers) # Speech-to-Text Models Section st.subheader("🎤 Speech-to-Text Models") @@ -309,7 +334,7 @@ with st.container(border=True): if st.button( "🗑️", key=f"delete_stt_{model.id}", help="Delete model" ): - model.delete() + models_service.delete_model(model.id) st.rerun() else: st.info("No speech-to-text models configured") @@ -321,6 +346,10 @@ with st.container(border=True): "Used for audio transcriptions", "speech_to_text", ) + + # Show info if no default STT model is selected + if not default_models.default_speech_to_text_model: + st.info("ℹ️ Select a default STT model to enable audio transcription features.") with col2: - add_model_form("speech_to_text", "main") + add_model_form("speech_to_text", "main", available_providers) diff --git a/pages/8_💱_Transformations.py b/pages/8_💱_Transformations.py index 940869c..d5fdd67 100644 --- a/pages/8_💱_Transformations.py +++ b/pages/8_💱_Transformations.py @@ -1,7 +1,7 @@ import streamlit as st +from api.transformations_service import transformations_service from open_notebook.domain.transformation import DefaultPrompts, Transformation -from open_notebook.graphs.transformation import graph as transformation_graph from pages.components.model_selector import model_selector from pages.stream_app.utils import setup_page @@ -11,7 +11,7 @@ transformations_tab, playground_tab = st.tabs(["🧩 Transformations", "🛝 Pla if "transformations" not in st.session_state: - st.session_state.transformations = Transformation.get_all(order_by="name asc") + st.session_state.transformations = transformations_service.get_all_transformations() else: # work-around for streamlit losing typing on session state st.session_state.transformations = [ @@ -37,8 +37,8 @@ with transformations_tab: default_prompts.update() st.toast("Default prompt saved successfully!") if st.button("Create new Transformation", icon="➕", key="new_transformation"): - new_transformation = Transformation( - name="New Tranformation", + new_transformation = transformations_service.create_transformation( + name="New Transformation", title="New Transformation Title", description="New Transformation Description", prompt="New Transformation Prompt", @@ -99,7 +99,7 @@ with transformations_tab: transformation.prompt = prompt transformation.apply_default = apply_default st.toast(f"Transformation '{name}' saved successfully!") - transformation.save() + transformations_service.update_transformation(transformation) st.rerun() if transformation.id: @@ -113,7 +113,7 @@ with transformations_tab: if st.button( "Delete", icon="❌", key=f"{transformation.id}_delete" ): - transformation.delete() + transformations_service.delete_transformation(transformation.id) st.session_state.transformations.remove(transformation) st.toast(f"Transformation '{name}' deleted successfully!") st.rerun() @@ -137,11 +137,12 @@ with playground_tab: input_text = st.text_area("Enter some text", height=200) if st.button("Run"): - output = transformation_graph.invoke( - dict( + if transformation and model and input_text: + result = transformations_service.execute_transformation( + transformation_id=transformation.id, input_text=input_text, - transformation=transformation, - ), - config=dict(configurable={"model_id": model.id}), - ) - st.markdown(output["output"]) + model_id=model.id + ) + st.markdown(result["output"]) + else: + st.warning("Please select a transformation, model, and enter some text.") diff --git a/pages/components/__init__.py b/pages/components/__init__.py index d6561b5..18ec872 100644 --- a/pages/components/__init__.py +++ b/pages/components/__init__.py @@ -1,11 +1,9 @@ from pages.components.note_panel import note_panel -from pages.components.source_embedding_panel import source_embedding_panel from pages.components.source_insight import source_insight_panel from pages.components.source_panel import source_panel __all__ = [ "note_panel", - "source_embedding_panel", "source_insight_panel", "source_panel", ] diff --git a/pages/components/model_selector.py b/pages/components/model_selector.py index 832367f..5d91fcf 100644 --- a/pages/components/model_selector.py +++ b/pages/components/model_selector.py @@ -2,8 +2,12 @@ from typing import Literal import streamlit as st +from api.models_service import ModelsService from open_notebook.domain.models import Model +# Initialize service instance +models_service = ModelsService() + def model_selector( label, @@ -14,7 +18,7 @@ def model_selector( "language", "embedding", "speech_to_text", "text_to_speech" ] = "language", ) -> Model: - models = Model.get_models_by_type(model_type) + models = models_service.get_all_models(model_type=model_type) models.sort(key=lambda x: (x.provider, x.name)) try: index = ( diff --git a/pages/components/note_panel.py b/pages/components/note_panel.py index 3d67cd1..307561f 100644 --- a/pages/components/note_panel.py +++ b/pages/components/note_panel.py @@ -2,17 +2,22 @@ import streamlit as st from loguru import logger from streamlit_monaco import st_monaco # type: ignore -from open_notebook.domain.models import model_manager -from open_notebook.domain.notebook import Note +from api.models_service import ModelsService +from api.notes_service import NotesService from pages.stream_app.utils import convert_source_references +# Initialize service instances +models_service = ModelsService() +notes_service = NotesService() + def note_panel(note_id, notebook_id=None): - if not model_manager.embedding_model: + default_models = models_service.get_default_models() + if not default_models.default_embedding_model: st.warning( "Since there is no embedding model selected, your note will be saved but not searchable." ) - note: Note = Note.get(note_id) + note = notes_service.get_note(note_id) if not note: raise ValueError(f"Note not fonud {note_id}") t_preview, t_edit = st.tabs(["Preview", "Edit"]) @@ -27,11 +32,18 @@ def note_panel(note_id, notebook_id=None): b1, b2 = st.columns(2) if b1.button("Save", key=f"pn_edit_note_{note.id or 'new'}"): logger.debug("Editing note") - note.save() - if not note.id and notebook_id: - note.add_to_notebook(notebook_id) + if note.id: + notes_service.update_note(note) + else: + note = notes_service.create_note( + content=note.content, + title=note.title, + note_type=note.note_type, + notebook_id=notebook_id, + ) st.rerun() if b2.button("Delete", type="primary", key=f"delete_note_{note.id or 'new'}"): logger.debug("Deleting note") - note.delete() + if note.id: + notes_service.delete_note(note.id) st.rerun() diff --git a/pages/components/source_embedding_panel.py b/pages/components/source_embedding_panel.py deleted file mode 100644 index 4ef4a29..0000000 --- a/pages/components/source_embedding_panel.py +++ /dev/null @@ -1,17 +0,0 @@ -import streamlit as st - -from open_notebook.domain.notebook import SourceEmbedding - - -def source_embedding_panel(source_embedding_id): - si: SourceEmbedding = SourceEmbedding.get(source_embedding_id) - if not si: - raise ValueError(f"Embedding not found {source_embedding_id}") - with st.container(border=True): - url = f"Navigator?object_id={si.source.id}" - st.markdown("**Original Source**") - st.markdown(f"{si.source.title} [link](%s)" % url) - st.markdown(si.content) - if st.button("Delete", type="primary", key=f"delete_embedding_{si.id or 'new'}"): - si.delete() - st.rerun() diff --git a/pages/components/source_insight.py b/pages/components/source_insight.py index ad38793..ac5aaaf 100644 --- a/pages/components/source_insight.py +++ b/pages/components/source_insight.py @@ -1,18 +1,27 @@ +import asyncio + +import nest_asyncio import streamlit as st +nest_asyncio.apply() + +from api.insights_service import insights_service +from api.sources_service import sources_service from open_notebook.domain.notebook import SourceInsight def source_insight_panel(source, notebook_id=None): - si: SourceInsight = SourceInsight.get(source) + si: SourceInsight = insights_service.get_insight(source) if not si: raise ValueError(f"insight not found {source}") st.subheader(si.insight_type) with st.container(border=True): - url = f"Navigator?object_id={si.source.id}" + # Get source information using the source_id from the insight + source_obj = sources_service.get_source(si._source_id) + url = f"Navigator?object_id={source_obj.id}" st.markdown("**Original Source**") - st.markdown(f"{si.source.title} [link](%s)" % url) + st.markdown(f"{source_obj.title} [link](%s)" % url) st.markdown(si.content) if st.button("Delete", type="primary", key=f"delete_insight_{si.id or 'new'}"): - si.delete() + insights_service.delete_insight(si.id) st.rerun() diff --git a/pages/components/source_panel.py b/pages/components/source_panel.py index 791fee4..51adf0a 100644 --- a/pages/components/source_panel.py +++ b/pages/components/source_panel.py @@ -1,77 +1,77 @@ -import asyncio - -import nest_asyncio import streamlit as st from humanize import naturaltime -from open_notebook.domain.models import model_manager -from open_notebook.domain.notebook import Source -from open_notebook.domain.transformation import Transformation -from open_notebook.graphs.transformation import graph as transform_graph +from api.insights_service import insights_service +from api.sources_service import SourcesService +from api.transformations_service import TransformationsService +from api.models_service import ModelsService from pages.stream_app.utils import check_models -nest_asyncio.apply() +# Initialize service instances +sources_service = SourcesService() +transformations_service = TransformationsService() +models_service = ModelsService() def source_panel(source_id: str, notebook_id=None, modal=False): check_models(only_mandatory=False) - source: Source = Source.get(source_id) - if not source: + source_with_metadata = sources_service.get_source(source_id) + if not source_with_metadata: raise ValueError(f"Source not found: {source_id}") - current_title = source.title if source.title else "No Title" - source.title = st.text_input("Title", value=current_title) - if source.title != current_title: + # Now we can access both the source and embedded_chunks directly + current_title = source_with_metadata.title if source_with_metadata.title else "No Title" + source_with_metadata.title = st.text_input("Title", value=current_title) + if source_with_metadata.title != current_title: + sources_service.update_source(source_with_metadata.source) st.toast("Saved new Title") - source.save() process_tab, source_tab = st.tabs(["Process", "Source"]) with process_tab: c1, c2 = st.columns([4, 2]) with c1: title = st.empty() - if source.title: - title.subheader(source.title) - if source.asset and source.asset.url: - from_src = f"from URL: {source.asset.url}" - elif source.asset and source.asset.file_path: - from_src = f"from file: {source.asset.file_path}" + if source_with_metadata.title: + title.subheader(source_with_metadata.title) + if source_with_metadata.asset and source_with_metadata.asset.url: + from_src = f"from URL: {source_with_metadata.asset.url}" + elif source_with_metadata.asset and source_with_metadata.asset.file_path: + from_src = f"from file: {source_with_metadata.asset.file_path}" else: from_src = "from text" - st.caption(f"Created {naturaltime(source.created)}, {from_src}") - for insight in source.insights: + st.caption(f"Created {naturaltime(source_with_metadata.created)}, {from_src}") + for insight in insights_service.get_source_insights(source_with_metadata.id): with st.expander(f"**{insight.insight_type}**"): st.markdown(insight.content) x1, x2 = st.columns(2) if x1.button( "Delete", type="primary", key=f"delete_insight_{insight.id}" ): - insight.delete() + insights_service.delete_insight(insight.id) st.rerun(scope="fragment" if modal else "app") - st.toast("Source deleted") + st.toast("Insight deleted") if notebook_id: if x2.button( "Save as Note", icon="📝", key=f"save_note_{insight.id}" ): - insight.save_as_note(notebook_id) + insights_service.save_insight_as_note(insight.id, notebook_id) st.toast("Saved as Note. Refresh the Notebook to see it.") with c2: - transformations = Transformation.get_all(order_by="name asc") + transformations = transformations_service.get_all_transformations() if transformations: with st.container(border=True): transformation = st.selectbox( "Run a transformation", transformations, - key=f"transformation_{source.id}", + key=f"transformation_{source_with_metadata.id}", format_func=lambda x: x.name, ) st.caption(transformation.description if transformation else "") if st.button("Run"): - asyncio.run( - transform_graph.ainvoke( - input=dict(source=source, transformation=transformation) - ) + insights_service.create_source_insight( + source_id=source_with_metadata.id, + transformation_id=transformation.id ) st.rerun(scope="fragment" if modal else "app") else: @@ -79,32 +79,36 @@ def source_panel(source_id: str, notebook_id=None, modal=False): "No transformations created yet. Create new Transformation to use this feature." ) - if not model_manager.embedding_model: + default_models = models_service.get_default_models() + embedding_model = default_models.default_embedding_model + if not embedding_model: help = ( "No embedding model found. Please, select one on the Models page." ) else: help = "This will generate your embedding vectors on the database for powerful search capabilities" - if source.embedded_chunks == 0 and st.button( + if not source_with_metadata.embedded_chunks and st.button( "Embed vectors", icon="🦾", help=help, - disabled=model_manager.embedding_model is None, + disabled=not embedding_model, ): - source.vectorize() - st.success("Embedding complete") + from api.embedding_service import embedding_service + + result = embedding_service.embed_content(source_with_metadata.id, "source") + st.success(result.get("message", "Embedding complete")) with st.container(border=True): st.caption( "Deleting the source will also delete all its insights and embeddings" ) if st.button( - "Delete", type="primary", key=f"bt_delete_source_{source.id}" + "Delete", type="primary", key=f"bt_delete_source_{source_with_metadata.id}" ): - source.delete() + sources_service.delete_source(source_with_metadata.id) st.rerun() with source_tab: st.subheader("Content") - st.markdown(source.full_text) + st.markdown(source_with_metadata.full_text) diff --git a/pages/stream_app/auth.py b/pages/stream_app/auth.py new file mode 100644 index 0000000..a97307d --- /dev/null +++ b/pages/stream_app/auth.py @@ -0,0 +1,52 @@ +import os +import streamlit as st + + +def check_password(): + """ + Check if the user has entered the correct password. + Returns True if authenticated or no password is set. + """ + # Get the password from environment variable + app_password = os.environ.get("OPEN_NOTEBOOK_PASSWORD") + + # If no password is set, skip authentication + if not app_password: + return True + + # Check if already authenticated in this session + if "authenticated" in st.session_state and st.session_state.authenticated: + return True + + # Show login form + with st.container(): + st.markdown("### 🔒 Authentication Required") + st.markdown("This Open Notebook instance is password protected.") + + with st.form("login_form"): + password = st.text_input( + "Password", + type="password", + placeholder="Enter password" + ) + submitted = st.form_submit_button("Login") + + if submitted: + if password == app_password: + st.session_state.authenticated = True + st.success("Successfully authenticated!") + st.rerun() + else: + st.error("Incorrect password. Please try again.") + + # Stop execution if not authenticated + if "authenticated" not in st.session_state or not st.session_state.authenticated: + st.stop() + + return True + + +def logout(): + """Clear authentication from session state.""" + if "authenticated" in st.session_state: + del st.session_state.authenticated \ No newline at end of file diff --git a/pages/stream_app/chat.py b/pages/stream_app/chat.py index b616d20..c843a58 100644 --- a/pages/stream_app/chat.py +++ b/pages/stream_app/chat.py @@ -1,27 +1,31 @@ -from typing import Union +import asyncio import humanize import streamlit as st from langchain_core.runnables import RunnableConfig +from loguru import logger -from open_notebook.domain.base import ObjectModel -from open_notebook.domain.notebook import ChatSession, Note, Notebook, Source +from api.episode_profiles_service import episode_profiles_service +from api.podcast_service import PodcastService +from open_notebook.domain.notebook import ChatSession, Notebook from open_notebook.graphs.chat import graph as chat_graph -from open_notebook.plugins.podcasts import PodcastConfig -from open_notebook.utils import token_count + +# from open_notebook.plugins.podcasts import PodcastConfig +from open_notebook.utils import parse_thinking_content, token_count from pages.stream_app.utils import ( convert_source_references, create_session_for_notebook, ) -from open_notebook.utils import parse_thinking_content - from .note import make_note_from_chat # todo: build a smarter, more robust context manager function def build_context(notebook_id): - st.session_state[notebook_id]["context"] = dict(note=[], source=[]) + from api.context_service import context_service + + # Convert context_config format for API + context_config = {"sources": {}, "notes": {}} for id, status in st.session_state[notebook_id]["context_config"].items(): if not id: @@ -31,22 +35,21 @@ def build_context(notebook_id): if item_type not in ["note", "source"]: continue - if "not in" in status: - continue + if item_type == "source": + context_config["sources"][item_id] = status + elif item_type == "note": + context_config["notes"][item_id] = status - try: - item: Union[Note, Source] = ObjectModel.get(id) - except Exception: - continue + # Get context via API + result = context_service.get_notebook_context( + notebook_id=notebook_id, context_config=context_config + ) - if "insights" in status: - st.session_state[notebook_id]["context"][item_type] += [ - item.get_context(context_size="short") - ] - elif "full content" in status: - st.session_state[notebook_id]["context"][item_type] += [ - item.get_context(context_size="long") - ] + # Store in session state for compatibility + st.session_state[notebook_id]["context"] = { + "note": result["notes"], + "source": result["sources"], + } return st.session_state[notebook_id]["context"] @@ -73,55 +76,91 @@ def chat_sidebar(current_notebook: Notebook, current_session: ChatSession): st.json(context) with podcast_tab: with st.container(border=True): - podcast_configs = PodcastConfig.get_all() - podcast_config_names = [pd.name for pd in podcast_configs] - if len(podcast_configs) == 0: - st.warning("No podcast configurations found") - else: - template = st.selectbox("Pick a template", podcast_config_names) - selected_template = next( - filter(lambda x: x.name == template, podcast_configs) - ) - episode_name = st.text_input("Episode Name") - instructions = st.text_area( - "Instructions", value=selected_template.user_instructions - ) - podcast_length = st.radio( - "Podcast Length", - ["Short (5-10 min)", "Medium (10-20 min)", "Longer (20+ min)"], - ) - chunks = None - min_chunk_size = None - if podcast_length == "Short (5-10 min)": - longform = False - elif podcast_length == "Medium (10-20 min)": - longform = True - chunks = 4 - min_chunk_size = 600 - else: - longform = True - chunks = 8 - min_chunk_size = 600 + # Fetch available episode profiles + try: + episode_profiles = episode_profiles_service.get_all_episode_profiles() + episode_profile_names = [ep.name for ep in episode_profiles] + except Exception as e: + st.error(f"Failed to load episode profiles: {str(e)}") + episode_profiles = [] + episode_profile_names = [] + if len(episode_profiles) == 0: + st.warning( + "No episode profiles found. Please create profiles in the Podcast Profiles tab first." + ) + st.page_link("pages/5_🎙️_Podcasts.py", label="🎙️ Go to Podcast Profiles") + else: + # Episode Profile selection + selected_episode_profile = st.selectbox( + "Episode Profile", episode_profile_names + ) + + # Get the selected episode profile object to access speaker_config + selected_profile_obj = next( + ( + ep + for ep in episode_profiles + if ep.name == selected_episode_profile + ), + None, + ) + + # Episode details + episode_name = st.text_input( + "Episode Name", placeholder="e.g., AI and the Future of Work" + ) + instructions = st.text_area( + "Additional Instructions (Optional)", + placeholder="Any specific instructions beyond the episode profile's default briefing...", + help="These instructions will be added to the episode profile's default briefing.", + ) + + # Check for context availability if len(context.get("note", [])) + len(context.get("source", [])) == 0: st.warning( "No notes or sources found in context. You don't want a boring podcast, right? So, add some context first." ) else: - try: - if st.button("Generate"): - with st.spinner("Go grab a coffee, almost there..."): - selected_template.generate_episode( - episode_name=episode_name, - text=str(context), - longform=longform, - chunks=chunks, - min_chunk_size=min_chunk_size, - instructions=instructions, - ) - st.success("Episode generated successfully") - except Exception as e: - st.error(f"Error generating episode - {str(e)}") + # Generate button + if st.button("🎙️ Generate Podcast", type="primary"): + if not episode_name.strip(): + st.error("Please enter an episode name") + else: + try: + with st.spinner("Starting podcast generation..."): + # Use podcast service to generate podcast + async def generate_podcast(): + return await PodcastService.submit_generation_job( + episode_profile_name=selected_episode_profile, + speaker_profile_name=selected_profile_obj.speaker_config + if selected_profile_obj + else "", + episode_name=episode_name.strip(), + content=str(context), + briefing_suffix=instructions.strip() + if instructions.strip() + else None, + notebook_id=str(current_notebook.id), + ) + + job_id = asyncio.run(generate_podcast()) + + if job_id: + st.info( + "🎉 Podcast generation started successfully! Check the **Podcasts** page to monitor progress and download results." + ) + else: + st.error( + "Failed to start podcast generation: No job ID returned" + ) + + except Exception as e: + logger.error(f"Error generating podcast: {str(e)}") + st.error(f"Error generating podcast: {str(e)}") + + # Navigation link + st.divider() st.page_link("pages/5_🎙️_Podcasts.py", label="🎙️ Go to Podcasts") with chat_tab: with st.expander( @@ -155,7 +194,7 @@ def chat_sidebar(current_notebook: Notebook, current_session: ChatSession): st.session_state[current_notebook.id]["active_session"] = new_session.id st.rerun() st.divider() - sessions = current_notebook.chat_sessions + sessions = asyncio.run(current_notebook.get_chat_sessions()) if len(sessions) > 1: st.markdown("**Other Sessions:**") for session in sessions: @@ -190,19 +229,23 @@ def chat_sidebar(current_notebook: Notebook, current_session: ChatSession): with st.chat_message(name=msg.type): if msg.type == "ai": # Parse thinking content for AI messages - thinking_content, cleaned_content = parse_thinking_content(msg.content) - + thinking_content, cleaned_content = parse_thinking_content( + msg.content + ) + # Show thinking content in expander if present if thinking_content: with st.expander("🤔 AI Reasoning", expanded=False): st.markdown(thinking_content) - + # Show the cleaned regular content if cleaned_content: st.markdown(convert_source_references(cleaned_content)) - elif msg.content: # Fallback to original if cleaning resulted in empty content + elif ( + msg.content + ): # Fallback to original if cleaning resulted in empty content st.markdown(convert_source_references(msg.content)) - + # New Note button for AI messages if st.button("💾 New Note", key=f"render_save_{msg.id}"): make_note_from_chat( diff --git a/pages/stream_app/note.py b/pages/stream_app/note.py index 4738d76..011a6dd 100644 --- a/pages/stream_app/note.py +++ b/pages/stream_app/note.py @@ -3,10 +3,9 @@ from typing import Optional import streamlit as st from humanize import naturaltime -from open_notebook.domain.models import model_manager +from api.models_service import models_service +from api.notes_service import notes_service from open_notebook.domain.notebook import Note -from open_notebook.graphs.prompt import graph as prompt_graph -from open_notebook.utils import surreal_clean from pages.components import note_panel from .consts import note_context_icons @@ -14,16 +13,20 @@ from .consts import note_context_icons @st.dialog("Write a Note", width="large") def add_note(notebook_id): - if not model_manager.embedding_model: + default_models = models_service.get_default_models() + if not default_models.default_embedding_model: st.warning( "Since there is no embedding model selected, your note will be saved but not searchable." ) note_title = st.text_input("Title") note_content = st.text_area("Content") if st.button("Save", key="add_note"): - note = Note(title=note_title, content=note_content, note_type="human") - note.save() - note.add_to_notebook(notebook_id) + notes_service.create_note( + content=note_content, + title=note_title, + note_type="human", + notebook_id=notebook_id + ) st.rerun() @@ -33,19 +36,13 @@ def note_panel_dialog(note: Optional[Note] = None, notebook_id=None): def make_note_from_chat(content, notebook_id=None): - # todo: make this more efficient - prompt = "Based on the Note below, please provide a Title for this content, with max 15 words" - output = prompt_graph.invoke(dict(input_text=content, prompt=prompt)) - title = surreal_clean(output["output"]) - - note = Note( - title=title, + # Title will be auto-generated by the API for AI notes + notes_service.create_note( content=content, + title=None, # Let API generate it note_type="ai", + notebook_id=notebook_id ) - note.save() - if notebook_id: - note.add_to_notebook(notebook_id) st.rerun() @@ -74,7 +71,7 @@ def note_card(note, notebook_id): def note_list_item(note_id, score=None): - note: Note = Note.get(note_id) + note = notes_service.get_note(note_id) if note.note_type == "human": icon = "🤵" else: diff --git a/pages/stream_app/source.py b/pages/stream_app/source.py index 300c5a4..1c95440 100644 --- a/pages/stream_app/source.py +++ b/pages/stream_app/source.py @@ -1,24 +1,20 @@ -import asyncio import os from pathlib import Path -import nest_asyncio import streamlit as st from humanize import naturaltime from loguru import logger +from api.insights_service import insights_service +from api.models_service import models_service +from api.settings_service import settings_service +from api.sources_service import sources_service +from api.transformations_service import transformations_service from open_notebook.config import UPLOADS_FOLDER -from open_notebook.domain.content_settings import ContentSettings -from open_notebook.domain.models import model_manager -from open_notebook.domain.notebook import Source -from open_notebook.domain.transformation import Transformation from open_notebook.exceptions import UnsupportedTypeException -from open_notebook.graphs.source import source_graph from pages.components import source_panel from pages.stream_app.consts import source_context_icons -nest_asyncio.apply() - @st.dialog("Source", width="large") def source_panel_dialog(source_id, notebook_id=None): @@ -27,17 +23,18 @@ def source_panel_dialog(source_id, notebook_id=None): @st.dialog("Add a Source", width="large") def add_source(notebook_id): - if not model_manager.speech_to_text: + default_models = models_service.get_default_models() + if not default_models.default_speech_to_text_model: st.warning( "Since there is no speech to text model selected, you can't upload audio/video files." ) source_link = None source_file = None source_text = None - content_settings = ContentSettings() + content_settings = settings_service.get_settings() source_type = st.radio("Type", ["Link", "Upload", "Text"]) req = {} - transformations = Transformation.get_all() + transformations = transformations_service.get_all_transformations() if source_type == "Link": source_link = st.text_input("Link") req["url"] = source_link @@ -49,7 +46,6 @@ def add_source(notebook_id): source_text = st.text_area("Text") req["content"] = source_text - transformations = Transformation.get_all() default_transformations = [t for t in transformations if t.apply_default] apply_transformations = st.multiselect( "Apply transformations", @@ -97,16 +93,41 @@ def add_source(notebook_id): with open(new_path, "wb") as f: f.write(source_file.getbuffer()) - asyncio.run( - source_graph.ainvoke( - { - "content_state": req, - "notebook_id": notebook_id, - "apply_transformations": apply_transformations, - "embed": run_embed, - } - ) + from api.sources_service import sources_service + + # Convert transformations to IDs + transformation_ids = ( + [t.id for t in apply_transformations] + if apply_transformations + else [] ) + + # Determine source type and parameters + if source_type == "Link": + sources_service.create_source( + notebook_id=notebook_id, + source_type="link", + url=source_link, + transformations=transformation_ids, + embed=run_embed, + ) + elif source_type == "Upload": + sources_service.create_source( + notebook_id=notebook_id, + source_type="upload", + file_path=req["file_path"], + transformations=transformation_ids, + embed=run_embed, + delete_source=req.get("delete_source", False), + ) + else: # Text + sources_service.create_source( + notebook_id=notebook_id, + source_type="text", + content=source_text, + transformations=transformation_ids, + embed=run_embed, + ) except UnsupportedTypeException as e: st.warning( "This type of content is not supported yet. If you think it should be, let us know on the project Issues's page" @@ -139,8 +160,10 @@ def source_card(source, notebook_id): index=1, key=f"source_{source.id}", ) + + insights = insights_service.get_source_insights(source.id) st.caption( - f"Updated: {naturaltime(source.updated)}, **{len(source.insights)}** insights" + f"Updated: {naturaltime(source.updated)}, **{len(insights)}** insights" ) if st.button("Expand", icon="📝", key=source.id): source_panel_dialog(source.id, notebook_id) @@ -149,7 +172,8 @@ def source_card(source, notebook_id): def source_list_item(source_id, score=None): - source: Source = Source.get(source_id) + source_with_metadata = sources_service.get_source(source_id) + source = source_with_metadata.source if not source: st.error("Source not found") return diff --git a/pages/stream_app/utils.py b/pages/stream_app/utils.py index 44f5056..f135a9e 100644 --- a/pages/stream_app/utils.py +++ b/pages/stream_app/utils.py @@ -1,12 +1,15 @@ +import asyncio import re from datetime import datetime from typing import List, Union +import nest_asyncio import streamlit as st from loguru import logger +nest_asyncio.apply() +from api.models_service import models_service from open_notebook.database.migrate import MigrationManager -from open_notebook.domain.models import DefaultModels from open_notebook.domain.notebook import ChatSession, Notebook from open_notebook.graphs.chat import ThreadState, graph from open_notebook.utils import ( @@ -42,8 +45,8 @@ def create_session_for_notebook(notebook_id: str, session_name: str = None): current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") title = f"Chat Session {current_time}" if not session_name else session_name chat_session = ChatSession(title=title) - chat_session.save() - chat_session.relate_to_notebook(notebook_id) + asyncio.run(chat_session.save()) + asyncio.run(chat_session.relate_to_notebook(notebook_id)) return chat_session @@ -64,12 +67,12 @@ def setup_stream_state(current_notebook: Notebook) -> ChatSession: # gets the chat session if provided chat_session: Union[ChatSession, None] = ( - ChatSession.get(current_session_id) if current_session_id else None + asyncio.run(ChatSession.get(current_session_id)) if current_session_id else None ) # if there is no chat session, create one or get the first one if not chat_session: - sessions: List[ChatSession] = current_notebook.chat_sessions + sessions: List[ChatSession] = asyncio.run(current_notebook.get_chat_sessions()) if not sessions or len(sessions) == 0: logger.debug("Creating new chat session") chat_session = create_session_for_notebook(current_notebook.id) @@ -115,7 +118,7 @@ def check_migration(): def check_models(only_mandatory=True, stop_on_error=True): - default_models = DefaultModels() + default_models = models_service.get_default_models() mandatory_models = [ default_models.default_chat_model, default_models.default_transformation_model, @@ -160,15 +163,25 @@ def setup_page( sidebar_state="expanded", only_check_mandatory_models=True, stop_on_model_error=True, + skip_model_check=False, ): """Common page setup for all pages""" st.set_page_config( page_title=title, layout=layout, initial_sidebar_state=sidebar_state ) + + # Check authentication first + from pages.stream_app.auth import check_password + check_password() + check_migration() - check_models( - only_mandatory=only_check_mandatory_models, stop_on_error=stop_on_model_error - ) + + # Skip model check if requested (e.g., on Models page) + if not skip_model_check: + check_models( + only_mandatory=only_check_mandatory_models, stop_on_error=stop_on_model_error + ) + version_sidebar() diff --git a/pyproject.toml b/pyproject.toml index 598c3ff..dfe8768 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "open-notebook" -version = "0.2.3" +version = "0.3.0" description = "An open source implementation of a research assistant, inspired by Google Notebook LM" authors = [ {name = "Luis Novo", email = "lfnovo@gmail.com"} @@ -14,6 +14,8 @@ classifiers = [ requires-python = ">=3.11,<3.13" dependencies = [ "streamlit>=1.45.0", + "fastapi>=0.104.0", + "uvicorn>=0.24.0", "pydantic>=2.9.2", "loguru>=0.7.2", "langchain>=0.3.3", @@ -36,13 +38,14 @@ dependencies = [ "groq>=0.12.0", "python-dotenv>=1.0.1", "httpx[socks]>=0.27.0", - "sdblpy", - "podcastfy", "nest-asyncio>=1.6.0", "content-core>=1.0.2", "ai-prompter>=0.3", "esperanto>=2.0.4", "langchain-google-vertexai>=2.0.10", + "surrealdb>=1.0.4", + "surreal-commands>=1.0.13", + "podcast-creator>=0.2.6", ] [tool.setuptools] @@ -79,7 +82,3 @@ line-length = 88 [tool.ruff.lint] select = ["E", "F", "I"] ignore = ["E501"] - -[tool.uv.sources] -sdblpy = { git = "https://github.com/lfnovo/surreal-lite-py" } -podcastfy = { git = "https://github.com/lfnovo/podcastfy" } diff --git a/run_api.py b/run_api.py new file mode 100644 index 0000000..17062d2 --- /dev/null +++ b/run_api.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python3 +""" +Startup script for Open Notebook API server. +""" + +import os +import sys +from pathlib import Path + +import uvicorn + +# Add the current directory to Python path so imports work +current_dir = Path(__file__).parent +sys.path.insert(0, str(current_dir)) + +if __name__ == "__main__": + # Default configuration + host = os.getenv("API_HOST", "127.0.0.1") + port = int(os.getenv("API_PORT", "5055")) + reload = os.getenv("API_RELOAD", "true").lower() == "true" + + print(f"Starting Open Notebook API server on {host}:{port}") + print(f"Reload mode: {reload}") + + uvicorn.run( + "api.main:app", + host=host, + port=port, + reload=reload, + reload_dirs=[str(current_dir)] if reload else None, + ) diff --git a/setup_guide/DOCKER_SETUP_ADVANCED.md b/setup_guide/DOCKER_SETUP_ADVANCED.md new file mode 100644 index 0000000..704c9de --- /dev/null +++ b/setup_guide/DOCKER_SETUP_ADVANCED.md @@ -0,0 +1,283 @@ +# Open Notebook - Advanced Docker Setup Guide + +**Ready to supercharge your Open Notebook experience? This guide covers advanced AI providers and configurations.** + +## Prerequisites + +Before following this guide, you should have: +- ✅ Completed the [basic Docker setup guide](DOCKER_SETUP_GUIDE.md) +- ✅ Open Notebook running successfully with OpenAI +- ✅ Created your first notebook and added some sources + +## Overview: Why Go Advanced? + +While OpenAI provides excellent all-in-one functionality, you might want to explore: +- **More AI models**: Access to Claude, Gemini, Llama, and 100+ others +- **Cost optimization**: Some providers offer better pricing for specific tasks +- **Privacy**: Run models locally on your computer +- **Specialized models**: Better performance for specific use cases + +## Option 1: Add OpenRouter (Recommended) + +OpenRouter gives you access to virtually every AI model available today through a single API. + +### Why OpenRouter? +- **100+ models**: Claude, Gemini, Llama, Mistral, and more +- **Cost-effective**: Often cheaper than going direct to providers +- **Easy integration**: Works alongside your existing OpenAI setup +- **No upfront costs**: Pay as you go + +### Getting Your OpenRouter API Key + +1. Go to https://openrouter.ai/keys +2. Create an account or sign in +3. Click **"Create Key"** +4. Copy the key (starts with "sk-or-") +5. **No upfront payment required** - you can start using many models immediately + +### Adding OpenRouter to Your Configuration + +1. **Stop Open Notebook**: + ```bash + docker-compose down + ``` + +2. **Edit your `docker.env` file** and add the OpenRouter key: + ```env + # REQUIRED: Your OpenAI API key + OPENAI_API_KEY=YOUR_OPENAI_API_KEY_HERE + + # OPTIONAL: OpenRouter for access to many models + OPENROUTER_API_KEY=YOUR_OPENROUTER_API_KEY_HERE + + # Database settings (don't change these) + SURREAL_ADDRESS=surrealdb + SURREAL_PORT=8000 + SURREAL_USER=root + SURREAL_PASS=root + SURREAL_NAMESPACE=open_notebook + SURREAL_DATABASE=production + ``` + +3. **Start Open Notebook again**: + ```bash + docker-compose up -d + ``` + +4. **Configure new models**: + - Go to Settings → Models + - You'll now see many more model options from different providers + - Try models like `anthropic/claude-3-haiku` or `google/gemini-pro` + +### Recommended OpenRouter Models + +**For Chat (Alternative to GPT-4)**: +- `anthropic/claude-3-haiku` - Fast and cost-effective +- `google/gemini-pro` - Good reasoning capabilities +- `meta-llama/llama-3-8b-instruct` - Open source option + +**For Advanced Tasks**: +- `anthropic/claude-3-opus` - Best quality for complex tasks +- `google/gemini-pro-1.5` - Excellent for long context + +**For Cost-Conscious Users**: +- `meta-llama/llama-3-8b-instruct` - Very affordable +- `mistral/mistral-7b-instruct` - Good balance of cost and quality + +## Option 2: Add Ollama (Local Models) + +Run AI models directly on your computer for complete privacy and no API costs. + +### Why Ollama? +- **Complete privacy**: Your data never leaves your computer +- **No API costs**: Free to use once set up +- **Offline capability**: Works without internet connection +- **Control**: Full control over your AI models + +### Requirements +- **Powerful computer**: 16GB RAM minimum, 32GB recommended +- **Good CPU/GPU**: Modern processor, GPU acceleration helpful +- **Disk space**: 4-20GB per model + +### Installing Ollama + +1. **Download Ollama**: Go to https://ollama.ai and download for your system +2. **Install the application** following the instructions for your OS +3. **Start Ollama**: Run `ollama serve` in terminal +4. **Download models**: + ```bash + ollama pull llama2 # 7B model (~4GB) + ollama pull mistral # 7B model (~4GB) + ollama pull llama2:13b # 13B model (~8GB) - better quality + ``` + +### Configuring Ollama with Docker + +Docker containers can't use "localhost" to reach your computer, so we need to configure the IP address. + +1. **Find your computer's IP address**: + - **Windows**: Open Command Prompt, run `ipconfig`, look for "IPv4 Address" + - **macOS**: Open Terminal, run `ifconfig | grep inet`, look for your local IP + - **Linux**: Run `ip addr show` or `hostname -I` + - Your IP will be something like `192.168.1.100` or `10.0.0.50` + +2. **Stop Open Notebook**: + ```bash + docker-compose down + ``` + +3. **Edit your `docker.env` file** and add the Ollama configuration: + ```env + # REQUIRED: Your OpenAI API key + OPENAI_API_KEY=YOUR_OPENAI_API_KEY_HERE + + # OPTIONAL: OpenRouter for access to many models + OPENROUTER_API_KEY=YOUR_OPENROUTER_API_KEY_HERE + + # OPTIONAL: Ollama for local models + # Replace 192.168.1.100 with your actual IP address + OLLAMA_API_BASE=http://192.168.1.100:11434 + + # Database settings (don't change these) + SURREAL_ADDRESS=localhost + SURREAL_PORT=8000 + SURREAL_USER=root + SURREAL_PASS=root + SURREAL_NAMESPACE=open_notebook + SURREAL_DATABASE=production + ``` + +4. **Make sure your firewall allows connections** to port 11434 + +5. **Start Open Notebook**: + ```bash + docker-compose up -d + ``` + +6. **Test the connection**: + - Go to Settings → Models + - You should see your Ollama models listed + - If not, double-check your IP address and firewall settings + +### Recommended Ollama Models + +**For Beginners**: +- `llama2` (7B) - Good balance of quality and speed +- `mistral` (7B) - Fast and capable + +**For Better Quality** (requires more RAM): +- `llama2:13b` (13B) - Better responses, slower +- `codellama` (7B) - Great for programming tasks + +**For Advanced Users**: +- `llama2:70b` (70B) - Excellent quality, requires 64GB+ RAM +- `mistral:7b-instruct` - Fine-tuned for following instructions + +## Option 3: Additional Providers + +### Anthropic (Claude Direct) +If you want to use Claude directly instead of through OpenRouter: + +1. Get your API key at https://console.anthropic.com/ +2. Add to `docker.env`: + ```env + ANTHROPIC_API_KEY=YOUR_ANTHROPIC_API_KEY_HERE + ``` + +### Google Gemini (Direct) +For direct access to Google's models: + +1. Get your API key at https://makersuite.google.com/app/apikey +2. Add to `docker.env`: + ```env + GEMINI_API_KEY=YOUR_GEMINI_API_KEY_HERE + ``` + +### Groq (Fast Inference) +For very fast model inference: + +1. Get your API key at https://console.groq.com/keys +2. Add to `docker.env`: + ```env + GROQ_API_KEY=YOUR_GROQ_API_KEY_HERE + ``` + +## Complete Configuration Example + +Here's a complete `docker.env` file with all providers: + +```env +# REQUIRED: Your OpenAI API key +OPENAI_API_KEY=sk-1234567890abcdef... + +# OPTIONAL: Additional providers +OPENROUTER_API_KEY=sk-or-v1-1234567890abcdef... +ANTHROPIC_API_KEY=sk-ant-1234567890abcdef... +GEMINI_API_KEY=AIzaSy1234567890abcdef... +GROQ_API_KEY=gsk_1234567890abcdef... + +# OPTIONAL: Ollama for local models +OLLAMA_API_BASE=http://192.168.1.100:11434 + +# OPTIONAL: For podcast generation +ELEVENLABS_API_KEY=sk_1234567890abcdef... + +# Database settings (don't change these) +SURREAL_ADDRESS=surrealdb +SURREAL_PORT=8000 +SURREAL_USER=root +SURREAL_PASS=root +SURREAL_NAMESPACE=open_notebook +SURREAL_DATABASE=production +``` + +## Advanced Model Configuration Tips + +### Cost Optimization +- Use **OpenRouter** for expensive models (Claude, GPT-4) +- Use **Ollama** for simple tasks to save API costs +- Monitor usage at each provider's dashboard + +### Performance Optimization +- Use **Groq** for fast inference when speed matters +- Use **local models** when privacy is crucial +- Use **OpenAI** for best reliability and features + +### Specialized Tasks +- **Code generation**: `codellama` (Ollama) or `gpt-4` (OpenAI) +- **Long documents**: `claude-3-opus` (Anthropic) or `gemini-pro-1.5` (Google) +- **Creative writing**: `claude-3-opus` (Anthropic) or `gpt-4` (OpenAI) + +## Troubleshooting Advanced Setups + +### OpenRouter Issues +- **Models not appearing**: Check your API key is correct +- **Rate limits**: Some models have usage limits +- **Costs**: Monitor usage at https://openrouter.ai/activity + +### Ollama Issues +- **Models not detected**: Check IP address and firewall +- **Slow performance**: Try smaller models or upgrade hardware +- **Connection refused**: Ensure `ollama serve` is running + +### General Tips +- **Start small**: Add one provider at a time +- **Test thoroughly**: Verify each provider works before adding more +- **Monitor costs**: Set up billing alerts for cloud providers +- **Keep backups**: Save working configurations + +## Getting Help + +- **Discord**: Join our community at https://discord.gg/37XJPXfz2w +- **GitHub Issues**: Report problems at https://github.com/lfnovo/open-notebook/issues +- **Documentation**: Visit https://www.open-notebook.ai + +## What's Next? + +With your advanced setup complete, you can: +- **Experiment with different models** for various tasks +- **Compare quality and costs** across providers +- **Build custom workflows** using the best model for each task +- **Contribute to the project** by sharing your experience + +Happy exploring! 🚀 \ No newline at end of file diff --git a/setup_guide/README.md b/setup_guide/README.md new file mode 100644 index 0000000..aa3df1c --- /dev/null +++ b/setup_guide/README.md @@ -0,0 +1,280 @@ +# Open Notebook - Docker Setup Guide for Beginners + +**A step-by-step guide to get Open Notebook running with Docker - no technical experience required!** + +## What You'll Get + +Open Notebook is a powerful AI-powered research and note-taking tool that: +- Helps you organize research across multiple notebooks +- Lets you chat with your documents using AI +- Supports multiple AI providers (OpenAI, Anthropic, Google, and more) +- Creates AI-generated podcasts from your content +- Works with PDFs, web links, videos, audio files, and more + +## Prerequisites + +Before we start, you'll need: +- A computer running Windows, macOS, or Linux +- An internet connection +- At least one AI provider API key (see section below) + +## Step 1: Install Docker Desktop + +Docker Desktop is the software that will run Open Notebook on your computer. + +### For Windows: +1. Go to https://www.docker.com/products/docker-desktop/ +2. Click "Download for Windows" +3. Run the downloaded installer +4. Follow the installation wizard +5. Restart your computer when prompted + +### For macOS: +1. Go to https://www.docker.com/products/docker-desktop/ +2. Click "Download for Mac" +3. Choose your Mac type (Intel or Apple Silicon) +4. Open the downloaded .dmg file +5. Drag Docker to your Applications folder +6. Open Docker from Applications + +### For Linux (Ubuntu/Debian): +1. Open Terminal +2. Run these commands one by one: +```bash +sudo apt update +sudo apt install docker.io docker-compose +sudo systemctl start docker +sudo systemctl enable docker +sudo usermod -aG docker $USER +``` +3. Log out and log back in + +## Step 2: Get Your OpenAI API Key + +Open Notebook uses OpenAI's powerful AI models. With just one API key, you'll have access to everything you need: +- **Text generation** for chat and notes +- **Embeddings** for search functionality +- **Text-to-speech** for podcast generation +- **Speech-to-text** for audio transcription + +### How to Get Your OpenAI API Key + +1. Go to https://platform.openai.com/ +2. Create an account or sign in +3. Click on **"API Keys"** in the left sidebar +4. Click **"Create new secret key"** +5. Give your key a name (e.g., "Open Notebook") +6. Copy the key that appears (it starts with "sk-") +7. **Save this key somewhere safe** - you won't be able to see it again! + +### Add Credits to Your Account + +**Important**: OpenAI requires you to add credits before you can use the API. + +1. In the OpenAI platform, click **"Billing"** in the sidebar +2. Click **"Add payment details"** +3. Add at least **$5 in credits** (this will last a long time for personal use) +4. You can set up usage limits to control spending + +## Step 3: Create Your Configuration Files + +### Create the docker-compose.yml file + +1. Create a new folder on your computer called `open-notebook` +2. Open a text editor (Notepad on Windows, TextEdit on Mac, or any text editor) +3. Copy and paste this content -- or download it from [here](https://github.com/lfnovo/open-notebook/blob/main/docker-compose.yml): + +```yaml +services: + open_notebook: + image: lfnovo/open_notebook:latest-single + ports: + - "8080:8502" + env_file: + - ./docker.env + pull_policy: always + volumes: + - ./notebook_data:/app/data + - ./surreal_data:/app/surreal_data + restart: always +``` + +4. Save this file as `docker-compose.yml` in your `open-notebook` folder + +### Create the docker.env file + +1. In the same `open-notebook` folder, create a new file +2. Copy and paste this content, replacing `YOUR_OPENAI_API_KEY_HERE` with your actual API key -- or download it from [here](https://github.com/lfnovo/open-notebook/blob/main/.env.example) - be sure to rename it to `docker.env`: + +```env +# REQUIRED: Your OpenAI API key +OPENAI_API_KEY=YOUR_OPENAI_API_KEY_HERE + +# Database settings (don't change these) +SURREAL_ADDRESS=localhost +SURREAL_PORT=8000 +SURREAL_USER=root +SURREAL_PASS=root +SURREAL_NAMESPACE=open_notebook +SURREAL_DATABASE=production +``` + +3. **Important**: Replace `YOUR_OPENAI_API_KEY_HERE` with your actual API key from Step 2 +4. Save this file as `docker.env` in your `open-notebook` folder + +## Step 4: Start Open Notebook + +### Windows: +1. Open Command Prompt +2. Navigate to your open-notebook folder: `cd C:\path\to\your\open-notebook` +3. Run: `docker-compose up -d` + +### macOS/Linux: +1. Open Terminal +2. Navigate to your open-notebook folder: `cd /path/to/your/open-notebook` +3. Run: `docker-compose up -d` + +### What happens next: +- Docker will download the necessary files (this might take a few minutes the first time) +- Two services will start: the database and Open Notebook +- You'll see messages indicating the services are starting + +### Important + +- Make sure that Docker Desktop is running before starting Open Notebook. +- Make sure both the `docker-compose.yml` and `docker.env` files are in this folder where you run the `docker-compose up -d` command. + +## Step 5: Access Open Notebook + +1. Open your web browser +2. Go to: http://localhost:8502 +3. You should see the Open Notebook interface! + +## Step 6: Configure Your AI Models + +Before creating your first notebook, you need to set up which AI models to use for different tasks. + +### Navigate to Models Settings + +1. Click on **"⚙️ Settings"** in the sidebar +2. Click on **"🤖 Models"** tab + +### Set Up Your Models + +You'll need to configure models for different purposes. Here are the recommended OpenAI models for each category: + +#### 1. **Language Models** (For conversations and general AI assistance) +- **Recommended**: `gpt-4o-mini` (fast and cost-effective) +- **Alternative**: `gpt-4o` (more powerful but costs more) + +#### 2. **Embedding Model** (For search and finding similar content) +- **Recommended**: `text-embedding-3-small` (best balance) +- **Alternative**: `text-embedding-3-large` (better quality, costs more) +- **Note**: This is required for the search feature to work + +#### 3. **Text-To-Speech Model** (For processing your documents) +- **Recommended**: `gpt-4o-mini-tts` (handles long documents well) +- **Alternative**: `tts-1` (cheaper, less quality) + +#### 4. **Speech-to-Text Model** (For generating podcasts) +- **Recommended**: `whisper-1` (best quality for creative content) + +### How to Configure Each Model + +1. For each model category, click the dropdown menu +2. Select your chosen model from the list +3. Click **"Save"** after configuring all models +4. You should see a success message + +### Tips for Model Selection + +- **Start with the recommended models** - they provide the best balance of quality and cost +- **You can change models anytime** - experiment to find what works best +- **Check your OpenAI usage** - monitor costs at https://platform.openai.com/usage +- **All these models use your OpenAI API key** - no additional setup needed + +## Step 7: Create Your First Notebook + +1. Click "Create New Notebook" +2. Give it a name (e.g., "My Research") +3. Add a description +4. Click "Create" + +## Step 8: Add Your First Source + +1. In your new notebook, click "Add Source" +2. Choose from: + - **Link**: Paste any web URL + - **File**: Upload PDFs, documents, audio, or video files + - **Text**: Paste text directly +3. Click "Add Source" +4. Wait for processing to complete + +## Step 9: Start Using Open Notebook + +Now you can: +- **Chat with your content**: Use the chat panel to ask questions about your sources +- **Create notes**: Write or generate AI-powered notes +- **Generate podcasts**: Create multi-speaker podcasts from your content +- **Search**: Find information across all your sources +- **Add more sources**: Keep building your knowledge base + +## Troubleshooting + +### Port already in use +If you get an error about port 8502 being in use: +1. Stop the current container: `docker-compose down` +2. Wait a few seconds +3. Start again: `docker-compose up -d` + +### Can't access the interface +- Make sure Docker Desktop is running +- Check that both containers are running: `docker-compose ps` +- Try restarting: `docker-compose restart` + +### API key errors +- Double-check your API keys in the `docker.env` file +- Make sure you have credits in your AI provider account +- Verify the keys don't have extra spaces or characters + +### General issues +1. Stop everything: `docker-compose down` +2. Remove old containers: `docker-compose down -v` +3. Start fresh: `docker-compose up -d` + +## Stopping Open Notebook + +To stop Open Notebook: +```bash +docker-compose down +``` + +To start it again: +```bash +docker-compose up -d +``` + +## Getting Help + +- **Discord**: Join the Open Notebook community at https://discord.gg/37XJPXfz2w +- **GitHub Issues**: Report bugs at https://github.com/lfnovo/open-notebook/issues +- **Documentation**: Visit https://www.open-notebook.ai for more features and guides + +## Next Steps + +Once you're comfortable with the basics: +- Try the transformation features to extract insights +- Create multi-speaker podcasts from your research +- Experiment with different OpenAI models for various tasks +- Explore the search functionality to find information quickly + +## Ready for More? Check Out the Advanced Guide! + +Now that you have Open Notebook running with OpenAI, you might want to explore more AI providers and advanced features. Check out our [Advanced Docker Setup Guide](DOCKER_SETUP_ADVANCED.md) to learn about: + +- **OpenRouter**: Access to 100+ models from different providers (Claude, Gemini, Llama, etc.) +- **Ollama**: Run AI models locally on your computer for complete privacy +- **Additional providers**: Anthropic, Google, Groq, and more +- **Advanced configurations**: Custom model settings and optimizations + +Welcome to Open Notebook! 🚀 \ No newline at end of file diff --git a/setup_guide/docker-compose.yml b/setup_guide/docker-compose.yml new file mode 100644 index 0000000..7ee2eb7 --- /dev/null +++ b/setup_guide/docker-compose.yml @@ -0,0 +1,12 @@ +services: + open_notebook: + image: lfnovo/open_notebook:latest-single + ports: + - "8080:8502" + env_file: + - ./docker.env + pull_policy: always + volumes: + - ./notebook_data:/app/data + - ./surreal_data:/app/surreal_data + restart: always diff --git a/setup_guide/docker.env b/setup_guide/docker.env new file mode 100644 index 0000000..b7962da --- /dev/null +++ b/setup_guide/docker.env @@ -0,0 +1,13 @@ + + +OPENAI_API_KEY= + + +# CONNECTION DETAILS FOR YOUR SURREAL DB +# use localhost if using the single container, or surrealdb if using the multi-container +SURREAL_URL="ws://localhost/rpc:8000" +SURREAL_USER="root" +SURREAL_PASSWORD="root" +SURREAL_NAMESPACE="open_notebook" +SURREAL_DATABASE="staging" + diff --git a/supervisord.conf b/supervisord.conf index 8c06e5d..97c5537 100644 --- a/supervisord.conf +++ b/supervisord.conf @@ -4,18 +4,34 @@ logfile=/dev/stdout logfile_maxbytes=0 pidfile=/tmp/supervisord.pid -[program:surrealdb] -command=surreal start --log trace --user root --pass root rocksdb:/mydata/mydatabase.db +[program:api] +command=uv run uvicorn api.main:app --host 0.0.0.0 --port 5055 stdout_logfile=/dev/stdout stdout_logfile_maxbytes=0 stderr_logfile=/dev/stderr stderr_logfile_maxbytes=0 autorestart=true +priority=10 +autostart=true + +[program:worker] +command=uv run surreal-commands-worker --import-modules commands +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 +stderr_logfile=/dev/stderr +stderr_logfile_maxbytes=0 +autorestart=true +priority=20 +autostart=true +startsecs=3 [program:streamlit] -command=uv run --env-file .env streamlit run app_home.py +command=uv run streamlit run app_home.py --server.port=8502 --server.address=0.0.0.0 stdout_logfile=/dev/stdout stdout_logfile_maxbytes=0 stderr_logfile=/dev/stderr stderr_logfile_maxbytes=0 autorestart=true +priority=30 +autostart=true +startsecs=5 diff --git a/supervisord.single.conf b/supervisord.single.conf new file mode 100644 index 0000000..1072846 --- /dev/null +++ b/supervisord.single.conf @@ -0,0 +1,49 @@ +[supervisord] +nodaemon=true +logfile=/dev/stdout +logfile_maxbytes=0 +pidfile=/tmp/supervisord.pid + +[program:surrealdb] +command=surreal start --log trace --user root --pass root rocksdb:/mydata/mydatabase.db +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 +stderr_logfile=/dev/stderr +stderr_logfile_maxbytes=0 +autorestart=true +priority=5 +autostart=true +startsecs=5 + +[program:api] +command=uv run uvicorn api.main:app --host 0.0.0.0 --port 5055 +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 +stderr_logfile=/dev/stderr +stderr_logfile_maxbytes=0 +autorestart=true +priority=10 +autostart=true +startsecs=3 + +[program:worker] +command=uv run surreal-commands-worker --import-modules commands +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 +stderr_logfile=/dev/stderr +stderr_logfile_maxbytes=0 +autorestart=true +priority=20 +autostart=true +startsecs=3 + +[program:streamlit] +command=uv run streamlit run app_home.py --server.port=8502 --server.address=0.0.0.0 +stdout_logfile=/dev/stdout +stdout_logfile_maxbytes=0 +stderr_logfile=/dev/stderr +stderr_logfile_maxbytes=0 +autorestart=true +priority=30 +autostart=true +startsecs=5 \ No newline at end of file diff --git a/test_commands.sh b/test_commands.sh new file mode 100755 index 0000000..828270b --- /dev/null +++ b/test_commands.sh @@ -0,0 +1,90 @@ +#!/bin/bash + +echo "=== Testing Surreal Commands Integration ===" +echo "" + +# Base URL +BASE_URL="http://localhost:5055/api" + +# 1. Test text processing command +echo "1. Testing text processing command (uppercase)..." +curl -X POST "$BASE_URL/commands/jobs" \ + -H "Content-Type: application/json" \ + -d '{ + "command": "process_text", + "app": "open_notebook", + "input": { + "text": "Hello, this is a test message!", + "operation": "uppercase" + } + }' | jq . + +echo "" +echo "2. Testing text processing with delay (3 seconds)..." +curl -X POST "$BASE_URL/commands/jobs" \ + -H "Content-Type: application/json" \ + -d '{ + "command": "process_text", + "app": "open_notebook", + "input": { + "text": "Testing async behavior with delay", + "operation": "reverse", + "delay_seconds": 3 + } + }' | jq . + +echo "" +echo "3. Testing data analysis command..." +curl -X POST "$BASE_URL/commands/jobs" \ + -H "Content-Type: application/json" \ + -d '{ + "command": "analyze_data", + "app": "open_notebook", + "input": { + "numbers": [10, 20, 30, 40, 50], + "analysis_type": "basic" + } + }' | jq . + +echo "" +echo "4. Testing error scenario (empty numbers array)..." +curl -X POST "$BASE_URL/commands/jobs" \ + -H "Content-Type: application/json" \ + -d '{ + "command": "analyze_data", + "app": "open_notebook", + "input": { + "numbers": [], + "analysis_type": "basic" + } + }' | jq . + +echo "" +echo "5. Testing word count operation..." +curl -X POST "$BASE_URL/commands/jobs" \ + -H "Content-Type: application/json" \ + -d '{ + "command": "process_text", + "app": "open_notebook", + "input": { + "text": "This is a sample text with multiple words to count", + "operation": "word_count" + } + }' | jq . + +echo "" +echo "Please save the job_ids from above to check status!" +echo "" +echo "6. To check job status (replace JOB_ID with actual ID):" +echo "curl \"$BASE_URL/commands/jobs/{JOB_ID}\" | jq ." + +echo "" +echo "7. To list all jobs:" +echo "curl \"$BASE_URL/commands/jobs\" | jq ." + +echo "" +echo "=== Test Commands Complete ===" +echo "" +echo "Manual status check example:" +echo "Replace JOB_ID with one of the job IDs returned above:" +echo "curl \"$BASE_URL/commands/jobs/JOB_ID\" | jq ." \ No newline at end of file diff --git a/uv.lock b/uv.lock index cff08b5..28bfc32 100644 --- a/uv.lock +++ b/uv.lock @@ -1,43 +1,36 @@ version = 1 requires-python = ">=3.11, <3.13" resolution-markers = [ - "python_full_version < '3.12' and platform_system == 'Darwin'", - "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_system == 'Linux'", - "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_system == 'Linux') or (python_full_version < '3.12' and platform_system != 'Darwin' and platform_system != 'Linux')", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system == 'Darwin'", - "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux'", - "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system == 'Linux') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')", - "python_full_version >= '3.12.4' and platform_system == 'Darwin'", - "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux'", - "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system == 'Linux') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')", + "python_full_version < '3.12'", + "python_full_version >= '3.12'", ] [[package]] name = "ai-prompter" -version = "0.3.0" +version = "0.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jinja2" }, { name = "pip" }, { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/88/1a/263b2fb49a485d1b394ead887361cb8855ab28daa20a184cef0d2a0f8f2c/ai_prompter-0.3.0.tar.gz", hash = "sha256:3369555345386c6b9eebb7edbbb96df268977ab2657acb2890c217290bf92569", size = 74091 } +sdist = { url = "https://files.pythonhosted.org/packages/52/88/cadc58aac8bbb599d8c6d25f2cd357e938ddabe3756b1eed68e8860eed22/ai_prompter-0.3.1.tar.gz", hash = "sha256:cec7fddac5edf7d836c13fe77613e16b12b23aea625133846d11ae22455ed397", size = 84837 } wheels = [ - { url = "https://files.pythonhosted.org/packages/90/ae/cc493d9d37cd1501e442154aa7265fa05814d0e8519ddf549ebd2f5fcb1b/ai_prompter-0.3.0-py3-none-any.whl", hash = "sha256:b70569bf6a64258ab3453e1ff99a7a4cd1c7709296093dc2a35127230d408e7b", size = 8419 }, + { url = "https://files.pythonhosted.org/packages/7d/f6/490bf534d6b04755998142ec7412b78e7466dc6d9a3f31e90541506b7971/ai_prompter-0.3.1-py3-none-any.whl", hash = "sha256:ec26566f7f246f511325e1c0f260970963a6e49fb19ed0767152d30b82cd2b79", size = 13386 }, ] [[package]] name = "aiohappyeyeballs" -version = "2.6.1" +version = "2.4.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760 } +sdist = { url = "https://files.pythonhosted.org/packages/7f/55/e4373e888fdacb15563ef6fa9fa8c8252476ea071e96fb46defac9f18bf2/aiohappyeyeballs-2.4.4.tar.gz", hash = "sha256:5fdd7d87889c63183afc18ce9271f9b0a7d32c2303e394468dd45d514a757745", size = 21977 } wheels = [ - { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265 }, + { url = "https://files.pythonhosted.org/packages/b9/74/fbb6559de3607b3300b9be3cc64e97548d55678e44623db17820dbd20002/aiohappyeyeballs-2.4.4-py3-none-any.whl", hash = "sha256:a980909d50efcd44795c4afeca523296716d50cd756ddca6af8c65b996e27de8", size = 14756 }, ] [[package]] name = "aiohttp" -version = "3.12.13" +version = "3.11.11" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohappyeyeballs" }, @@ -48,42 +41,38 @@ dependencies = [ { name = "propcache" }, { name = "yarl" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/42/6e/ab88e7cb2a4058bed2f7870276454f85a7c56cd6da79349eb314fc7bbcaa/aiohttp-3.12.13.tar.gz", hash = "sha256:47e2da578528264a12e4e3dd8dd72a7289e5f812758fe086473fab037a10fcce", size = 7819160 } +sdist = { url = "https://files.pythonhosted.org/packages/fe/ed/f26db39d29cd3cb2f5a3374304c713fe5ab5a0e4c8ee25a0c45cc6adf844/aiohttp-3.11.11.tar.gz", hash = "sha256:bb49c7f1e6ebf3821a42d81d494f538107610c3a705987f53068546b0e90303e", size = 7669618 } wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/65/5566b49553bf20ffed6041c665a5504fb047cefdef1b701407b8ce1a47c4/aiohttp-3.12.13-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7c229b1437aa2576b99384e4be668af1db84b31a45305d02f61f5497cfa6f60c", size = 709401 }, - { url = "https://files.pythonhosted.org/packages/14/b5/48e4cc61b54850bdfafa8fe0b641ab35ad53d8e5a65ab22b310e0902fa42/aiohttp-3.12.13-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:04076d8c63471e51e3689c93940775dc3d12d855c0c80d18ac5a1c68f0904358", size = 481669 }, - { url = "https://files.pythonhosted.org/packages/04/4f/e3f95c8b2a20a0437d51d41d5ccc4a02970d8ad59352efb43ea2841bd08e/aiohttp-3.12.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:55683615813ce3601640cfaa1041174dc956d28ba0511c8cbd75273eb0587014", size = 469933 }, - { url = "https://files.pythonhosted.org/packages/41/c9/c5269f3b6453b1cfbd2cfbb6a777d718c5f086a3727f576c51a468b03ae2/aiohttp-3.12.13-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:921bc91e602d7506d37643e77819cb0b840d4ebb5f8d6408423af3d3bf79a7b7", size = 1740128 }, - { url = "https://files.pythonhosted.org/packages/6f/49/a3f76caa62773d33d0cfaa842bdf5789a78749dbfe697df38ab1badff369/aiohttp-3.12.13-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e72d17fe0974ddeae8ed86db297e23dba39c7ac36d84acdbb53df2e18505a013", size = 1688796 }, - { url = "https://files.pythonhosted.org/packages/ad/e4/556fccc4576dc22bf18554b64cc873b1a3e5429a5bdb7bbef7f5d0bc7664/aiohttp-3.12.13-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0653d15587909a52e024a261943cf1c5bdc69acb71f411b0dd5966d065a51a47", size = 1787589 }, - { url = "https://files.pythonhosted.org/packages/b9/3d/d81b13ed48e1a46734f848e26d55a7391708421a80336e341d2aef3b6db2/aiohttp-3.12.13-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a77b48997c66722c65e157c06c74332cdf9c7ad00494b85ec43f324e5c5a9b9a", size = 1826635 }, - { url = "https://files.pythonhosted.org/packages/75/a5/472e25f347da88459188cdaadd1f108f6292f8a25e62d226e63f860486d1/aiohttp-3.12.13-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d6946bae55fd36cfb8e4092c921075cde029c71c7cb571d72f1079d1e4e013bc", size = 1729095 }, - { url = "https://files.pythonhosted.org/packages/b9/fe/322a78b9ac1725bfc59dfc301a5342e73d817592828e4445bd8f4ff83489/aiohttp-3.12.13-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f95db8c8b219bcf294a53742c7bda49b80ceb9d577c8e7aa075612b7f39ffb7", size = 1666170 }, - { url = "https://files.pythonhosted.org/packages/7a/77/ec80912270e231d5e3839dbd6c065472b9920a159ec8a1895cf868c2708e/aiohttp-3.12.13-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:03d5eb3cfb4949ab4c74822fb3326cd9655c2b9fe22e4257e2100d44215b2e2b", size = 1714444 }, - { url = "https://files.pythonhosted.org/packages/21/b2/fb5aedbcb2b58d4180e58500e7c23ff8593258c27c089abfbcc7db65bd40/aiohttp-3.12.13-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6383dd0ffa15515283c26cbf41ac8e6705aab54b4cbb77bdb8935a713a89bee9", size = 1709604 }, - { url = "https://files.pythonhosted.org/packages/e3/15/a94c05f7c4dc8904f80b6001ad6e07e035c58a8ebfcc15e6b5d58500c858/aiohttp-3.12.13-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6548a411bc8219b45ba2577716493aa63b12803d1e5dc70508c539d0db8dbf5a", size = 1689786 }, - { url = "https://files.pythonhosted.org/packages/1d/fd/0d2e618388f7a7a4441eed578b626bda9ec6b5361cd2954cfc5ab39aa170/aiohttp-3.12.13-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:81b0fcbfe59a4ca41dc8f635c2a4a71e63f75168cc91026c61be665945739e2d", size = 1783389 }, - { url = "https://files.pythonhosted.org/packages/a6/6b/6986d0c75996ef7e64ff7619b9b7449b1d1cbbe05c6755e65d92f1784fe9/aiohttp-3.12.13-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6a83797a0174e7995e5edce9dcecc517c642eb43bc3cba296d4512edf346eee2", size = 1803853 }, - { url = "https://files.pythonhosted.org/packages/21/65/cd37b38f6655d95dd07d496b6d2f3924f579c43fd64b0e32b547b9c24df5/aiohttp-3.12.13-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5734d8469a5633a4e9ffdf9983ff7cdb512524645c7a3d4bc8a3de45b935ac3", size = 1716909 }, - { url = "https://files.pythonhosted.org/packages/fd/20/2de7012427dc116714c38ca564467f6143aec3d5eca3768848d62aa43e62/aiohttp-3.12.13-cp311-cp311-win32.whl", hash = "sha256:fef8d50dfa482925bb6b4c208b40d8e9fa54cecba923dc65b825a72eed9a5dbd", size = 427036 }, - { url = "https://files.pythonhosted.org/packages/f8/b6/98518bcc615ef998a64bef371178b9afc98ee25895b4f476c428fade2220/aiohttp-3.12.13-cp311-cp311-win_amd64.whl", hash = "sha256:9a27da9c3b5ed9d04c36ad2df65b38a96a37e9cfba6f1381b842d05d98e6afe9", size = 451427 }, - { url = "https://files.pythonhosted.org/packages/b4/6a/ce40e329788013cd190b1d62bbabb2b6a9673ecb6d836298635b939562ef/aiohttp-3.12.13-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0aa580cf80558557285b49452151b9c69f2fa3ad94c5c9e76e684719a8791b73", size = 700491 }, - { url = "https://files.pythonhosted.org/packages/28/d9/7150d5cf9163e05081f1c5c64a0cdf3c32d2f56e2ac95db2a28fe90eca69/aiohttp-3.12.13-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b103a7e414b57e6939cc4dece8e282cfb22043efd0c7298044f6594cf83ab347", size = 475104 }, - { url = "https://files.pythonhosted.org/packages/f8/91/d42ba4aed039ce6e449b3e2db694328756c152a79804e64e3da5bc19dffc/aiohttp-3.12.13-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78f64e748e9e741d2eccff9597d09fb3cd962210e5b5716047cbb646dc8fe06f", size = 467948 }, - { url = "https://files.pythonhosted.org/packages/99/3b/06f0a632775946981d7c4e5a865cddb6e8dfdbaed2f56f9ade7bb4a1039b/aiohttp-3.12.13-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c955989bf4c696d2ededc6b0ccb85a73623ae6e112439398935362bacfaaf6", size = 1714742 }, - { url = "https://files.pythonhosted.org/packages/92/a6/2552eebad9ec5e3581a89256276009e6a974dc0793632796af144df8b740/aiohttp-3.12.13-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d640191016763fab76072c87d8854a19e8e65d7a6fcfcbf017926bdbbb30a7e5", size = 1697393 }, - { url = "https://files.pythonhosted.org/packages/d8/9f/bd08fdde114b3fec7a021381b537b21920cdd2aa29ad48c5dffd8ee314f1/aiohttp-3.12.13-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4dc507481266b410dede95dd9f26c8d6f5a14315372cc48a6e43eac652237d9b", size = 1752486 }, - { url = "https://files.pythonhosted.org/packages/f7/e1/affdea8723aec5bd0959171b5490dccd9a91fcc505c8c26c9f1dca73474d/aiohttp-3.12.13-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8a94daa873465d518db073bd95d75f14302e0208a08e8c942b2f3f1c07288a75", size = 1798643 }, - { url = "https://files.pythonhosted.org/packages/f3/9d/666d856cc3af3a62ae86393baa3074cc1d591a47d89dc3bf16f6eb2c8d32/aiohttp-3.12.13-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:177f52420cde4ce0bb9425a375d95577fe082cb5721ecb61da3049b55189e4e6", size = 1718082 }, - { url = "https://files.pythonhosted.org/packages/f3/ce/3c185293843d17be063dada45efd2712bb6bf6370b37104b4eda908ffdbd/aiohttp-3.12.13-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f7df1f620ec40f1a7fbcb99ea17d7326ea6996715e78f71a1c9a021e31b96b8", size = 1633884 }, - { url = "https://files.pythonhosted.org/packages/3a/5b/f3413f4b238113be35dfd6794e65029250d4b93caa0974ca572217745bdb/aiohttp-3.12.13-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3062d4ad53b36e17796dce1c0d6da0ad27a015c321e663657ba1cc7659cfc710", size = 1694943 }, - { url = "https://files.pythonhosted.org/packages/82/c8/0e56e8bf12081faca85d14a6929ad5c1263c146149cd66caa7bc12255b6d/aiohttp-3.12.13-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:8605e22d2a86b8e51ffb5253d9045ea73683d92d47c0b1438e11a359bdb94462", size = 1716398 }, - { url = "https://files.pythonhosted.org/packages/ea/f3/33192b4761f7f9b2f7f4281365d925d663629cfaea093a64b658b94fc8e1/aiohttp-3.12.13-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:54fbbe6beafc2820de71ece2198458a711e224e116efefa01b7969f3e2b3ddae", size = 1657051 }, - { url = "https://files.pythonhosted.org/packages/5e/0b/26ddd91ca8f84c48452431cb4c5dd9523b13bc0c9766bda468e072ac9e29/aiohttp-3.12.13-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:050bd277dfc3768b606fd4eae79dd58ceda67d8b0b3c565656a89ae34525d15e", size = 1736611 }, - { url = "https://files.pythonhosted.org/packages/c3/8d/e04569aae853302648e2c138a680a6a2f02e374c5b6711732b29f1e129cc/aiohttp-3.12.13-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2637a60910b58f50f22379b6797466c3aa6ae28a6ab6404e09175ce4955b4e6a", size = 1764586 }, - { url = "https://files.pythonhosted.org/packages/ac/98/c193c1d1198571d988454e4ed75adc21c55af247a9fda08236602921c8c8/aiohttp-3.12.13-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e986067357550d1aaa21cfe9897fa19e680110551518a5a7cf44e6c5638cb8b5", size = 1724197 }, - { url = "https://files.pythonhosted.org/packages/e7/9e/07bb8aa11eec762c6b1ff61575eeeb2657df11ab3d3abfa528d95f3e9337/aiohttp-3.12.13-cp312-cp312-win32.whl", hash = "sha256:ac941a80aeea2aaae2875c9500861a3ba356f9ff17b9cb2dbfb5cbf91baaf5bf", size = 421771 }, - { url = "https://files.pythonhosted.org/packages/52/66/3ce877e56ec0813069cdc9607cd979575859c597b6fb9b4182c6d5f31886/aiohttp-3.12.13-cp312-cp312-win_amd64.whl", hash = "sha256:671f41e6146a749b6c81cb7fd07f5a8356d46febdaaaf07b0e774ff04830461e", size = 447869 }, + { url = "https://files.pythonhosted.org/packages/34/ae/e8806a9f054e15f1d18b04db75c23ec38ec954a10c0a68d3bd275d7e8be3/aiohttp-3.11.11-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ba74ec819177af1ef7f59063c6d35a214a8fde6f987f7661f4f0eecc468a8f76", size = 708624 }, + { url = "https://files.pythonhosted.org/packages/c7/e0/313ef1a333fb4d58d0c55a6acb3cd772f5d7756604b455181049e222c020/aiohttp-3.11.11-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4af57160800b7a815f3fe0eba9b46bf28aafc195555f1824555fa2cfab6c1538", size = 468507 }, + { url = "https://files.pythonhosted.org/packages/a9/60/03455476bf1f467e5b4a32a465c450548b2ce724eec39d69f737191f936a/aiohttp-3.11.11-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ffa336210cf9cd8ed117011085817d00abe4c08f99968deef0013ea283547204", size = 455571 }, + { url = "https://files.pythonhosted.org/packages/be/f9/469588603bd75bf02c8ffb8c8a0d4b217eed446b49d4a767684685aa33fd/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81b8fe282183e4a3c7a1b72f5ade1094ed1c6345a8f153506d114af5bf8accd9", size = 1685694 }, + { url = "https://files.pythonhosted.org/packages/88/b9/1b7fa43faf6c8616fa94c568dc1309ffee2b6b68b04ac268e5d64b738688/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3af41686ccec6a0f2bdc66686dc0f403c41ac2089f80e2214a0f82d001052c03", size = 1743660 }, + { url = "https://files.pythonhosted.org/packages/2a/8b/0248d19dbb16b67222e75f6aecedd014656225733157e5afaf6a6a07e2e8/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:70d1f9dde0e5dd9e292a6d4d00058737052b01f3532f69c0c65818dac26dc287", size = 1785421 }, + { url = "https://files.pythonhosted.org/packages/c4/11/f478e071815a46ca0a5ae974651ff0c7a35898c55063305a896e58aa1247/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:249cc6912405917344192b9f9ea5cd5b139d49e0d2f5c7f70bdfaf6b4dbf3a2e", size = 1675145 }, + { url = "https://files.pythonhosted.org/packages/26/5d/284d182fecbb5075ae10153ff7374f57314c93a8681666600e3a9e09c505/aiohttp-3.11.11-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0eb98d90b6690827dcc84c246811feeb4e1eea683c0eac6caed7549be9c84665", size = 1619804 }, + { url = "https://files.pythonhosted.org/packages/1b/78/980064c2ad685c64ce0e8aeeb7ef1e53f43c5b005edcd7d32e60809c4992/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec82bf1fda6cecce7f7b915f9196601a1bd1a3079796b76d16ae4cce6d0ef89b", size = 1654007 }, + { url = "https://files.pythonhosted.org/packages/21/8d/9e658d63b1438ad42b96f94da227f2e2c1d5c6001c9e8ffcc0bfb22e9105/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9fd46ce0845cfe28f108888b3ab17abff84ff695e01e73657eec3f96d72eef34", size = 1650022 }, + { url = "https://files.pythonhosted.org/packages/85/fd/a032bf7f2755c2df4f87f9effa34ccc1ef5cea465377dbaeef93bb56bbd6/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd176afcf8f5d2aed50c3647d4925d0db0579d96f75a31e77cbaf67d8a87742d", size = 1732899 }, + { url = "https://files.pythonhosted.org/packages/c5/0c/c2b85fde167dd440c7ba50af2aac20b5a5666392b174df54c00f888c5a75/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ec2aa89305006fba9ffb98970db6c8221541be7bee4c1d027421d6f6df7d1ce2", size = 1755142 }, + { url = "https://files.pythonhosted.org/packages/bc/78/91ae1a3b3b3bed8b893c5d69c07023e151b1c95d79544ad04cf68f596c2f/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:92cde43018a2e17d48bb09c79e4d4cb0e236de5063ce897a5e40ac7cb4878773", size = 1692736 }, + { url = "https://files.pythonhosted.org/packages/77/89/a7ef9c4b4cdb546fcc650ca7f7395aaffbd267f0e1f648a436bec33c9b95/aiohttp-3.11.11-cp311-cp311-win32.whl", hash = "sha256:aba807f9569455cba566882c8938f1a549f205ee43c27b126e5450dc9f83cc62", size = 416418 }, + { url = "https://files.pythonhosted.org/packages/fc/db/2192489a8a51b52e06627506f8ac8df69ee221de88ab9bdea77aa793aa6a/aiohttp-3.11.11-cp311-cp311-win_amd64.whl", hash = "sha256:ae545f31489548c87b0cced5755cfe5a5308d00407000e72c4fa30b19c3220ac", size = 442509 }, + { url = "https://files.pythonhosted.org/packages/69/cf/4bda538c502f9738d6b95ada11603c05ec260807246e15e869fc3ec5de97/aiohttp-3.11.11-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e595c591a48bbc295ebf47cb91aebf9bd32f3ff76749ecf282ea7f9f6bb73886", size = 704666 }, + { url = "https://files.pythonhosted.org/packages/46/7b/87fcef2cad2fad420ca77bef981e815df6904047d0a1bd6aeded1b0d1d66/aiohttp-3.11.11-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3ea1b59dc06396b0b424740a10a0a63974c725b1c64736ff788a3689d36c02d2", size = 464057 }, + { url = "https://files.pythonhosted.org/packages/5a/a6/789e1f17a1b6f4a38939fbc39d29e1d960d5f89f73d0629a939410171bc0/aiohttp-3.11.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8811f3f098a78ffa16e0ea36dffd577eb031aea797cbdba81be039a4169e242c", size = 455996 }, + { url = "https://files.pythonhosted.org/packages/b7/dd/485061fbfef33165ce7320db36e530cd7116ee1098e9c3774d15a732b3fd/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7227b87a355ce1f4bf83bfae4399b1f5bb42e0259cb9405824bd03d2f4336a", size = 1682367 }, + { url = "https://files.pythonhosted.org/packages/e9/d7/9ec5b3ea9ae215c311d88b2093e8da17e67b8856673e4166c994e117ee3e/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d40f9da8cabbf295d3a9dae1295c69975b86d941bc20f0a087f0477fa0a66231", size = 1736989 }, + { url = "https://files.pythonhosted.org/packages/d6/fb/ea94927f7bfe1d86178c9d3e0a8c54f651a0a655214cce930b3c679b8f64/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ffb3dc385f6bb1568aa974fe65da84723210e5d9707e360e9ecb51f59406cd2e", size = 1793265 }, + { url = "https://files.pythonhosted.org/packages/40/7f/6de218084f9b653026bd7063cd8045123a7ba90c25176465f266976d8c82/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8f5f7515f3552d899c61202d99dcb17d6e3b0de777900405611cd747cecd1b8", size = 1691841 }, + { url = "https://files.pythonhosted.org/packages/77/e2/992f43d87831cbddb6b09c57ab55499332f60ad6fdbf438ff4419c2925fc/aiohttp-3.11.11-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3499c7ffbfd9c6a3d8d6a2b01c26639da7e43d47c7b4f788016226b1e711caa8", size = 1619317 }, + { url = "https://files.pythonhosted.org/packages/96/74/879b23cdd816db4133325a201287c95bef4ce669acde37f8f1b8669e1755/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8e2bf8029dbf0810c7bfbc3e594b51c4cc9101fbffb583a3923aea184724203c", size = 1641416 }, + { url = "https://files.pythonhosted.org/packages/30/98/b123f6b15d87c54e58fd7ae3558ff594f898d7f30a90899718f3215ad328/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b6212a60e5c482ef90f2d788835387070a88d52cf6241d3916733c9176d39eab", size = 1646514 }, + { url = "https://files.pythonhosted.org/packages/d7/38/257fda3dc99d6978ab943141d5165ec74fd4b4164baa15e9c66fa21da86b/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d119fafe7b634dbfa25a8c597718e69a930e4847f0b88e172744be24515140da", size = 1702095 }, + { url = "https://files.pythonhosted.org/packages/0c/f4/ddab089053f9fb96654df5505c0a69bde093214b3c3454f6bfdb1845f558/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:6fba278063559acc730abf49845d0e9a9e1ba74f85f0ee6efd5803f08b285853", size = 1734611 }, + { url = "https://files.pythonhosted.org/packages/c3/d6/f30b2bc520c38c8aa4657ed953186e535ae84abe55c08d0f70acd72ff577/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:92fc484e34b733704ad77210c7957679c5c3877bd1e6b6d74b185e9320cc716e", size = 1694576 }, + { url = "https://files.pythonhosted.org/packages/bc/97/b0a88c3f4c6d0020b34045ee6d954058abc870814f6e310c4c9b74254116/aiohttp-3.11.11-cp312-cp312-win32.whl", hash = "sha256:9f5b3c1ed63c8fa937a920b6c1bec78b74ee09593b3f5b979ab2ae5ef60d7600", size = 411363 }, + { url = "https://files.pythonhosted.org/packages/7f/23/cc36d9c398980acaeeb443100f0216f50a7cfe20c67a9fd0a2f1a5a846de/aiohttp-3.11.11-cp312-cp312-win_amd64.whl", hash = "sha256:1e69966ea6ef0c14ee53ef7a3d68b564cc408121ea56c0caa2dc918c1b2f553d", size = 437666 }, ] [[package]] @@ -110,15 +99,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f5/10/6c25ed6de94c49f88a91fa5018cb4c0f3625f31d5be9f771ebe5cc7cd506/aiosqlite-0.21.0-py3-none-any.whl", hash = "sha256:2549cf4057f95f53dcba16f2b64e8e2791d7e1adedb13197dd8ed77bb226d7d0", size = 15792 }, ] -[[package]] -name = "alabaster" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929 }, -] - [[package]] name = "altair" version = "5.5.0" @@ -146,7 +126,7 @@ wheels = [ [[package]] name = "anthropic" -version = "0.54.0" +version = "0.57.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -157,9 +137,9 @@ dependencies = [ { name = "sniffio" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/89/28/80cb9bb6e7ce77d404145b51da4257455805c17f0a6be528ff3286e3882f/anthropic-0.54.0.tar.gz", hash = "sha256:5e6f997d97ce8e70eac603c3ec2e7f23addeff953fbbb76b19430562bb6ba815", size = 312376 } +sdist = { url = "https://files.pythonhosted.org/packages/d7/75/6261a1a8d92aed47e27d2fcfb3a411af73b1435e6ae1186da02b760565d0/anthropic-0.57.1.tar.gz", hash = "sha256:7815dd92245a70d21f65f356f33fc80c5072eada87fb49437767ea2918b2c4b0", size = 423775 } wheels = [ - { url = "https://files.pythonhosted.org/packages/de/b9/6ffb48e82c5e97b03cecee872d134a6b6666c2767b2d32ed709f3a60a8fe/anthropic-0.54.0-py3-none-any.whl", hash = "sha256:c1062a0a905daeec17ca9c06c401e4b3f24cb0495841d29d752568a1d4018d56", size = 288774 }, + { url = "https://files.pythonhosted.org/packages/e5/cf/ca0ba77805aec6171629a8b665c7dc224dab374539c3d27005b5d8c100a0/anthropic-0.57.1-py3-none-any.whl", hash = "sha256:33afc1f395af207d07ff1bffc0a3d1caac53c371793792569c5d2f09283ea306", size = 292779 }, ] [[package]] @@ -204,21 +184,21 @@ wheels = [ ] [[package]] -name = "attrs" -version = "25.3.0" +name = "async-timeout" +version = "5.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 } +sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274 } wheels = [ - { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 }, + { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233 }, ] [[package]] -name = "babel" -version = "2.17.0" +name = "attrs" +version = "25.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852 } +sdist = { url = "https://files.pythonhosted.org/packages/49/7c/fdf464bcc51d23881d110abd74b512a42b3d5d376a55a831b44c603ae17f/attrs-25.1.0.tar.gz", hash = "sha256:1c97078a80c814273a76b2a298a932eb681c87415c11dee0a6921de7f1b02c3e", size = 810562 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537 }, + { url = "https://files.pythonhosted.org/packages/fc/30/d4986a882011f9df997a55e6becd864812ccfcd821d64aac8570ee39f719/attrs-25.1.0-py3-none-any.whl", hash = "sha256:c75a69e28a550a7e93789579c22aa26b0f5b83b75dc4e08fe092980051e1090a", size = 63152 }, ] [[package]] @@ -234,23 +214,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/50/cd/30110dc0ffcf3b131156077b90e9f60ed75711223f306da4db08eff8403b/beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b", size = 187285 }, ] -[[package]] -name = "bleach" -version = "6.2.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "webencodings" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, -] - -[package.optional-dependencies] -css = [ - { name = "tinycss2" }, -] - [[package]] name = "blinker" version = "1.9.0" @@ -260,6 +223,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458 }, ] +[[package]] +name = "bottleneck" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/82/dd20e69b97b9072ed2d26cc95c0a573461986bf62f7fde7ac59143490918/bottleneck-1.5.0.tar.gz", hash = "sha256:c860242cf20e69d5aab2ec3c5d6c8c2a15f19e4b25b28b8fca2c2a12cefae9d8", size = 104177 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/5e/d66b2487c12fa3343013ac87a03bcefbeacf5f13ffa4ad56bb4bce319d09/bottleneck-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9be5dfdf1a662d1d4423d7b7e8dd9a1b7046dcc2ce67b6e94a31d1cc57a8558f", size = 99536 }, + { url = "https://files.pythonhosted.org/packages/28/24/e7030fe27c7a9eb9cc8c86a4d74a7422d2c3e3466aecdf658617bea40491/bottleneck-1.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16fead35c0b5d307815997eef67d03c2151f255ca889e0fc3d68703f41aa5302", size = 357134 }, + { url = "https://files.pythonhosted.org/packages/d0/ce/91b0514a7ac456d934ebd90f0cae2314302f33c16e9489c99a4f496b1cff/bottleneck-1.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:049162927cf802208cc8691fb99b108afe74656cdc96b9e2067cf56cb9d84056", size = 361243 }, + { url = "https://files.pythonhosted.org/packages/be/f7/1a41889a6c0863b9f6236c14182bfb5f37c964e791b90ba721450817fc24/bottleneck-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2f5e863a4fdaf9c85416789aeb333d1cdd3603037fd854ad58b0e2ac73be16cf", size = 361326 }, + { url = "https://files.pythonhosted.org/packages/d3/e8/d4772b5321cf62b53c792253e38db1f6beee4f2de81e65bce5a6fe78df8e/bottleneck-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8d123762f78717fc35ecf10cad45d08273fcb12ab40b3c847190b83fec236f03", size = 371849 }, + { url = "https://files.pythonhosted.org/packages/29/dc/f88f6d476d7a3d6bd92f6e66f814d0bf088be20f0c6f716caa2a2ca02e82/bottleneck-1.5.0-cp311-cp311-win32.whl", hash = "sha256:07c2c1aa39917b5c9be77e85791aa598e8b2c00f8597a198b93628bbfde72a3f", size = 107710 }, + { url = "https://files.pythonhosted.org/packages/17/03/f89a2eff4f919a7c98433df3be6fd9787c72966a36be289ec180f505b2d5/bottleneck-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:80ef9eea2a92fc5a1c04734aa1bcf317253241062c962eaa6e7f123b583d0109", size = 112055 }, + { url = "https://files.pythonhosted.org/packages/8e/64/127e174cec548ab98bc0fa868b4f5d3ae5276e25c856d31d235d83d885a8/bottleneck-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dbb0f0d38feda63050aa253cf9435e81a0ecfac954b0df84896636be9eabd9b6", size = 99640 }, + { url = "https://files.pythonhosted.org/packages/59/89/6e0b6463a36fd4771a9227d22ea904f892b80d95154399dd3e89fb6001f8/bottleneck-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:613165ce39bf6bd80f5307da0f05842ba534b213a89526f1eba82ea0099592fc", size = 358009 }, + { url = "https://files.pythonhosted.org/packages/f7/d6/7d1795a4a9e6383d3710a94c44010c7f2a8ba58cb5f2d9e2834a1c179afe/bottleneck-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f218e4dae6511180dcc4f06d8300e0c81e7f3df382091f464c5a919d289fab8e", size = 362875 }, + { url = "https://files.pythonhosted.org/packages/2b/1b/bab35ef291b9379a97e2fb986ce75f32eda38a47fc4954177b43590ee85e/bottleneck-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3886799cceb271eb67d057f6ecb13fb4582bda17a3b13b4fa0334638c59637c6", size = 361194 }, + { url = "https://files.pythonhosted.org/packages/d5/f3/a416fed726b81d2093578bc2112077f011c9f57b31e7ff3a1a9b00cce3d3/bottleneck-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dc8d553d4bf033d3e025cd32d4c034d2daf10709e31ced3909811d1c843e451c", size = 373253 }, + { url = "https://files.pythonhosted.org/packages/0a/40/c372f9e59b3ce340d170fbdc24c12df3d2b3c22c4809b149b7129044180b/bottleneck-1.5.0-cp312-cp312-win32.whl", hash = "sha256:0dca825048a3076f34c4a35409e3277b31ceeb3cbb117bbe2a13ff5c214bcabc", size = 107915 }, + { url = "https://files.pythonhosted.org/packages/28/5a/57571a3cd4e356bbd636bb2225fbe916f29adc2235ba3dc77cd4085c91c8/bottleneck-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f26005740e6ef6013eba8a48241606a963e862a601671eab064b7835cd12ef3d", size = 112148 }, +] + [[package]] name = "bs4" version = "0.0.2" @@ -282,12 +270,21 @@ wheels = [ ] [[package]] -name = "certifi" -version = "2025.6.15" +name = "cerberus" +version = "1.3.7" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/73/f7/f14b46d4bcd21092d7d3ccef689615220d8a08fb25e564b65d20738e672e/certifi-2025.6.15.tar.gz", hash = "sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b", size = 158753 } +sdist = { url = "https://files.pythonhosted.org/packages/08/92/6d861524d97a2c4913816309ca12afe313b32c8efc3ec641de98b890834b/cerberus-1.3.7.tar.gz", hash = "sha256:ecf249665400a0b7a9d5e4ee1ffc234fd5d003186d3e1904f70bc14038642c13", size = 29651 } wheels = [ - { url = "https://files.pythonhosted.org/packages/84/ae/320161bd181fc06471eed047ecce67b693fd7515b16d495d8932db763426/certifi-2025.6.15-py3-none-any.whl", hash = "sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057", size = 157650 }, + { url = "https://files.pythonhosted.org/packages/15/ce/e3abf3fd04da28978eefb06ea906549f20f23f2ec6df8873ede6b62c8a8c/Cerberus-1.3.7-py3-none-any.whl", hash = "sha256:180e7d1fa1a5765cbff7b5c716e52fddddfab859dc8f625b0d563ace4b7a7ab3", size = 30508 }, +] + +[[package]] +name = "certifi" +version = "2024.12.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/bd/1d41ee578ce09523c81a15426705dd20969f5abf006d1afe8aeff0dd776a/certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db", size = 166010 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/32/8f6669fc4798494966bf446c8c4a162e0b5d893dff088afddf76414f70e1/certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56", size = 164927 }, ] [[package]] @@ -344,37 +341,37 @@ wheels = [ [[package]] name = "charset-normalizer" -version = "3.4.2" +version = "3.4.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367 } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } wheels = [ - { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794 }, - { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846 }, - { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350 }, - { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657 }, - { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260 }, - { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164 }, - { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571 }, - { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952 }, - { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959 }, - { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030 }, - { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015 }, - { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106 }, - { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402 }, - { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936 }, - { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790 }, - { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924 }, - { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626 }, - { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567 }, - { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957 }, - { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408 }, - { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399 }, - { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815 }, - { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537 }, - { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565 }, - { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357 }, - { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776 }, - { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626 }, + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, ] [[package]] @@ -412,7 +409,7 @@ wheels = [ [[package]] name = "content-core" -version = "1.1.2" +version = "1.2.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ai-prompter" }, @@ -420,7 +417,6 @@ dependencies = [ { name = "asciidoc" }, { name = "bs4" }, { name = "dicttoxml" }, - { name = "docling" }, { name = "esperanto" }, { name = "firecrawl-py" }, { name = "jinja2" }, @@ -435,16 +431,16 @@ dependencies = [ { name = "python-docx" }, { name = "python-dotenv" }, { name = "python-magic" }, - { name = "python-magic-bin", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, + { name = "python-magic-bin", marker = "sys_platform == 'win32'" }, { name = "python-pptx" }, { name = "pytubefix" }, { name = "readability-lxml" }, { name = "validators" }, { name = "youtube-transcript-api" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/78333c36db1e5539d06bce494bf082d55b685a8586837ef06bff5b733aa4/content_core-1.1.2.tar.gz", hash = "sha256:168fcf183b8e6955eb763164171fb1e288c903b77a66b87ad4b4fcce65e95366", size = 20067031 } +sdist = { url = "https://files.pythonhosted.org/packages/5d/f9/455c408b1370103be09bcf23b09a4e27784b30ee69431ec3dceaca1350aa/content_core-1.2.3.tar.gz", hash = "sha256:99b40f0620bbbcbc7b05cad6c983b5629dc1aec2366dc375bfa3975e5fbcf29f", size = 20551768 } wheels = [ - { url = "https://files.pythonhosted.org/packages/60/86/7b34cf8e49a9a4ff55e2cb532b8f3f07c07da1046f450bb3e4f2cdc03d7c/content_core-1.1.2-py3-none-any.whl", hash = "sha256:e0123616fbe4d175ac0ebdee1be8bb2d0e1ba62842f0e62aa3fb954f5e813ba3", size = 158489 }, + { url = "https://files.pythonhosted.org/packages/96/16/29579f120cf45e66c2a0adb4a4eac37713ed29211b8314b69c9f10374bc7/content_core-1.2.3-py3-none-any.whl", hash = "sha256:9b8fbba5609c5e87ed176531fb9106568216482646ae9cffe787cf4fb4b66405", size = 164423 }, ] [[package]] @@ -456,35 +452,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ee/58/257350f7db99b4ae12b614a36256d9cc870d71d9e451e79c2dc3b23d7c3c/cssselect-1.3.0-py3-none-any.whl", hash = "sha256:56d1bf3e198080cc1667e137bc51de9cadfca259f03c2d4e09037b3e01e30f0d", size = 18786 }, ] -[[package]] -name = "cython" -version = "3.1.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/40/7b17cd866158238db704965da1b5849af261dbad393ea3ac966f934b2d39/cython-3.1.2.tar.gz", hash = "sha256:6bbf7a953fa6762dfecdec015e3b054ba51c0121a45ad851fa130f63f5331381", size = 3184825 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1f/de/502ddebaf5fe78f13cd6361acdd74710d3a5b15c22a9edc0ea4c873a59a5/cython-3.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5548573e0912d7dc80579827493315384c462e2f15797b91a8ed177686d31eb9", size = 3007792 }, - { url = "https://files.pythonhosted.org/packages/bb/c8/91b00bc68effba9ba1ff5b33988052ac4d98fc1ac3021ade7261661299c6/cython-3.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bf3ea5bc50d80762c490f42846820a868a6406fdb5878ae9e4cc2f11b50228a", size = 2870798 }, - { url = "https://files.pythonhosted.org/packages/f4/4b/29d290f14607785112c00a5e1685d766f433531bbd6a11ad229ab61b7a70/cython-3.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20ce53951d06ab2bca39f153d9c5add1d631c2a44d58bf67288c9d631be9724e", size = 3131280 }, - { url = "https://files.pythonhosted.org/packages/38/3c/7c61e9ce25377ec7c4aa0b7ceeed34559ebca7b5cfd384672ba64eeaa4ba/cython-3.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e05a36224e3002d48c7c1c695b3771343bd16bc57eab60d6c5d5e08f3cbbafd8", size = 3223898 }, - { url = "https://files.pythonhosted.org/packages/10/96/2d3fbe7e50e98b53ac86fefb48b64262b2e1304b3495e8e25b3cd1c3473e/cython-3.1.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbc0fc0777c7ab82297c01c61a1161093a22a41714f62e8c35188a309bd5db8e", size = 3291527 }, - { url = "https://files.pythonhosted.org/packages/bd/e4/4cd3624e250d86f05bdb121a567865b9cca75cdc6dce4eedd68e626ea4f8/cython-3.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:18161ef3dd0e90a944daa2be468dd27696712a5f792d6289e97d2a31298ad688", size = 3184034 }, - { url = "https://files.pythonhosted.org/packages/24/de/f8c1243c3e50ec95cb81f3a7936c8cf162f28050db8683e291c3861b46a0/cython-3.1.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ca45020950cd52d82189d6dfb6225737586be6fe7b0b9d3fadd7daca62eff531", size = 3386084 }, - { url = "https://files.pythonhosted.org/packages/c8/95/2365937da44741ef0781bb9ecc1f8f52b38b65acb7293b5fc7c3eaee5346/cython-3.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aaae97d6d07610224be2b73a93e9e3dd85c09aedfd8e47054e3ef5a863387dae", size = 3309974 }, - { url = "https://files.pythonhosted.org/packages/9b/b8/280eed114110a1a3aa9e2e76bcd06cdd5ef0df7ab77c0be9d5378ca28c57/cython-3.1.2-cp311-cp311-win32.whl", hash = "sha256:3d439d9b19e7e70f6ff745602906d282a853dd5219d8e7abbf355de680c9d120", size = 2482942 }, - { url = "https://files.pythonhosted.org/packages/a2/50/0aa65be5a4ab65bde3224b8fd23ed795f699d1e724ac109bb0a32036b82d/cython-3.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:8efa44ee2f1876e40eb5e45f6513a19758077c56bf140623ccab43d31f873b61", size = 2686535 }, - { url = "https://files.pythonhosted.org/packages/22/86/9393ab7204d5bb65f415dd271b658c18f57b9345d06002cae069376a5a7a/cython-3.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9c2c4b6f9a941c857b40168b3f3c81d514e509d985c2dcd12e1a4fea9734192e", size = 3015898 }, - { url = "https://files.pythonhosted.org/packages/f9/b8/3d10ac37ab7b7ee60bc6bfb48f6682ebee7fddaccf56e1e135f0d46ca79f/cython-3.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bdbc115bbe1b8c1dcbcd1b03748ea87fa967eb8dfc3a1a9bb243d4a382efcff4", size = 2846204 }, - { url = "https://files.pythonhosted.org/packages/f8/34/637771d8e10ebabc34a34cdd0d63fe797b66c334e150189955bf6442d710/cython-3.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05111f89db1ca98edc0675cfaa62be47b3ff519a29876eb095532a9f9e052b8", size = 3080671 }, - { url = "https://files.pythonhosted.org/packages/6b/c8/383ad1851fb272920a152c5a30bb6f08c3471b5438079d9488fc3074a170/cython-3.1.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6e7188df8709be32cfdfadc7c3782e361c929df9132f95e1bbc90a340dca3c7", size = 3199022 }, - { url = "https://files.pythonhosted.org/packages/e6/11/20adc8f2db37a29f245e8fd4b8b8a8245fce4bbbd128185cc9a7b1065e4c/cython-3.1.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c0ecc71e60a051732c2607b8eb8f2a03a5dac09b28e52b8af323c329db9987b", size = 3241337 }, - { url = "https://files.pythonhosted.org/packages/6f/0b/491f1fd3e177cccb6bb6d52f9609f78d395edde83ac47ebb06d21717ca29/cython-3.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f27143cf88835c8bcc9bf3304953f23f377d1d991e8942982fe7be344c7cfce3", size = 3131808 }, - { url = "https://files.pythonhosted.org/packages/db/d2/5e7053a3214c9baa7ad72940555eb87cf4750e597f10b2bb43db62c3f39f/cython-3.1.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d8c43566701133f53bf13485839d8f3f309095fe0d3b9d0cd5873073394d2edc", size = 3340319 }, - { url = "https://files.pythonhosted.org/packages/95/42/4842f8ddac9b36c94ae08b23c7fcde3f930c1dd49ac8992bb5320a4d96b5/cython-3.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a3bb893e85f027a929c1764bb14db4c31cbdf8a96f59a78f608f2ba7cfbbce95", size = 3287370 }, - { url = "https://files.pythonhosted.org/packages/03/0d/417745ed75d414176e50310087b43299a3e611e75c379ff998f60f2ca1a8/cython-3.1.2-cp312-cp312-win32.whl", hash = "sha256:12c5902f105e43ca9af7874cdf87a23627f98c15d5a4f6d38bc9d334845145c0", size = 2487734 }, - { url = "https://files.pythonhosted.org/packages/8e/82/df61d09ab81979ba171a8252af8fb8a3b26a0f19d1330c2679c11fe41667/cython-3.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:06789eb7bd2e55b38b9dd349e9309f794aee0fed99c26ea5c9562d463877763f", size = 2695542 }, - { url = "https://files.pythonhosted.org/packages/25/d6/ef8557d5e75cc57d55df579af4976935ee111a85bbee4a5b72354e257066/cython-3.1.2-py3-none-any.whl", hash = "sha256:d23fd7ffd7457205f08571a42b108a3cf993e83a59fe4d72b42e6fc592cf2639", size = 1224753 }, -] - [[package]] name = "dataclasses-json" version = "0.6.7" @@ -542,15 +509,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/09/40/9d521973cae7f7ef8b1f0d0e28a3db0f851c1f1dca45d4c2ed5360bb7246/dicttoxml-1.7.16-py3-none-any.whl", hash = "sha256:8677671496d0d38e66c7179f82a7e9059f94887777955dc71b0ac602ee637c26", size = 24155 }, ] -[[package]] -name = "dill" -version = "0.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/12/80/630b4b88364e9a8c8c5797f4602d0f76ef820909ee32f0bacb9f90654042/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0", size = 186976 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/50/3d/9373ad9c56321fdab5b41197068e1d8c25883b3fea29dd361f9b55116869/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049", size = 119668 }, -] - [[package]] name = "distlib" version = "0.3.9" @@ -569,118 +527,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277 }, ] -[[package]] -name = "docling" -version = "2.37.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "certifi" }, - { name = "docling-core", extra = ["chunking"] }, - { name = "docling-ibm-models" }, - { name = "docling-parse" }, - { name = "easyocr" }, - { name = "filetype" }, - { name = "huggingface-hub" }, - { name = "lxml" }, - { name = "marko" }, - { name = "openpyxl" }, - { name = "pandas" }, - { name = "pillow" }, - { name = "pluggy" }, - { name = "pydantic" }, - { name = "pydantic-settings" }, - { name = "pylatexenc" }, - { name = "pypdfium2" }, - { name = "python-docx" }, - { name = "python-pptx" }, - { name = "requests" }, - { name = "rtree" }, - { name = "scipy" }, - { name = "tqdm" }, - { name = "typer" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7b/8e/8f11f8a283c9aad442264ccc75f8d4d01a7253522c640113a7ebe90eb891/docling-2.37.0.tar.gz", hash = "sha256:0cb25462e5be4253555f10990b5b3bc71f8587f8662024f2656cb44cb9682960", size = 158701 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b5/fc/42cd32dbf396f297d528d7ecc36517dd768bbd74e4731d4bae2dcb4528e4/docling-2.37.0-py3-none-any.whl", hash = "sha256:2503dbd2accc6e38652b71700b03114ba917eceb40ddfa3c8dacf69aeccc5291", size = 178919 }, -] - -[[package]] -name = "docling-core" -version = "2.38.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jsonref" }, - { name = "jsonschema" }, - { name = "latex2mathml" }, - { name = "pandas" }, - { name = "pillow" }, - { name = "pydantic" }, - { name = "pyyaml" }, - { name = "tabulate" }, - { name = "typer" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/01/3d/02b4926567735c252b4750074f9dfc96d06078566f067eb47c13713952a2/docling_core-2.38.0.tar.gz", hash = "sha256:3bad4c476cc798e29d01b02ea383b5582d7031e9595b177be0a9450f2eb7bef6", size = 145997 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/52/e65521ec8ae7ecbce2f9dd95dbf4164b4d4c58c29136e1489a038ce9a2fc/docling_core-2.38.0-py3-none-any.whl", hash = "sha256:8f27d7074a99913f2ba73bde363bbed3416852014eda136bb8880d37805c6950", size = 151276 }, -] - -[package.optional-dependencies] -chunking = [ - { name = "semchunk" }, - { name = "transformers" }, -] - -[[package]] -name = "docling-ibm-models" -version = "3.5.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "docling-core" }, - { name = "huggingface-hub" }, - { name = "jsonlines" }, - { name = "numpy" }, - { name = "opencv-python-headless" }, - { name = "pillow" }, - { name = "pydantic" }, - { name = "rtree" }, - { name = "safetensors", extra = ["torch"] }, - { name = "torch" }, - { name = "torchvision" }, - { name = "tqdm" }, - { name = "transformers" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/62/1d/f2001370644dc460cebfabe015512e89c38cfccf9773b9459690a58dd477/docling_ibm_models-3.5.0.tar.gz", hash = "sha256:7c286e616f3a17466b61fa7f01de3d48a18418a2c12a1061aa196b907e517553", size = 81520 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/68/e2/5d81194405aa5789889543715715665ea8a5dba61599b545e48da1c10191/docling_ibm_models-3.5.0-py3-none-any.whl", hash = "sha256:9586635693f3c00ba1e66066bae20d8ee1f33b003e45a387cbf5ae3ae82e0e19", size = 81251 }, -] - -[[package]] -name = "docling-parse" -version = "4.0.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "docling-core" }, - { name = "pillow" }, - { name = "pydantic" }, - { name = "pywin32", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, - { name = "tabulate" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1a/3c/2702e1eecdf5c9645a851f93066e2789ee8e7ceb3662356d98ed6b9d0a91/docling_parse-4.0.5.tar.gz", hash = "sha256:4547308aeb97db4d3a1439fa0aca2521adbc9ad09ba2e46f85a89877f6981399", size = 36639400 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/98/22/0906ae0372747535d03beca47fb4945b0eac40948c1edbb0e7a02243c6d0/docling_parse-4.0.5-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:e9d5263080239ff7b4c4bf810aed33906b61a4c489364bdd66c885df5b59e1c1", size = 14708768 }, - { url = "https://files.pythonhosted.org/packages/00/5e/e21abbc28f4593297ab29a6e1e3a801241cb2b6c371c2e5df821dd7a059c/docling_parse-4.0.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:828bd5e4cb4e1136fdc9ece5b135657b491b984ffafe9dc9119de46a8fa92906", size = 14586971 }, - { url = "https://files.pythonhosted.org/packages/1b/38/d3703b2194bb075ef31c3a5eca95d947862d71ac891a00d397c51a57e044/docling_parse-4.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0ad5880a72b8b9af0b3e64f70a588ff241e808832d9ef8f8980630510a02a9f", size = 15033297 }, - { url = "https://files.pythonhosted.org/packages/04/79/f82707ec74f25b64919fb225463a3187c7edc0fb65d11b844c8f4c887485/docling_parse-4.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a65be212a47a80667a3edbec977e9d46ca69ce483e8ca47d6b0321a3b669f038", size = 15096314 }, - { url = "https://files.pythonhosted.org/packages/fb/66/a01ffb80bfc703f3fa3a4253a996d0309ed3c64c78a00284e6453d7b19e3/docling_parse-4.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:326168d8bcebb54d1be362b02bb432e1dfd897830f5a70df9ed99980b6432dee", size = 15890440 }, - { url = "https://files.pythonhosted.org/packages/f7/1e/4e58f10b218a2445d85d0f3f56b158ef2d477b167cd7e3b696a79269a2f8/docling_parse-4.0.5-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:478630da49c8e81ead6419f430579e938075ddd563ee6b01659f3ea70b2f0a68", size = 14709361 }, - { url = "https://files.pythonhosted.org/packages/06/99/ff53cdf6f09edd752f8e824c1065b86a1744b10a03a7013ef281c1ad6bb6/docling_parse-4.0.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9475d1fb881ceade1c82f63c78f04262b316c71bab477bb676af96fd4d786328", size = 14586483 }, - { url = "https://files.pythonhosted.org/packages/41/e8/0cc02dbdb25157989012a48e5ae9a295e8514d7f9852a1a67e3185b01ce7/docling_parse-4.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d835f91c2bd3c79dc7a54f9eec8c5eb9a0edf9435427eeb71b7e804edb33419", size = 15031273 }, - { url = "https://files.pythonhosted.org/packages/3e/8d/d5ed8e56c0558234859710b6cfbce397d09b35fae7223dfb6569d16f8bac/docling_parse-4.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2de91c8540b71d5824253a8e6ac0cb2079057d4a8c0bc1d4b138e51a413e6999", size = 15095233 }, - { url = "https://files.pythonhosted.org/packages/45/ef/220d8870f95b237634768854a68a564b6d8cc8d6006e8842bcf0dbbdd4fb/docling_parse-4.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:cb7763a1772023bf7490ba6fbe553e8173cac400310930278a55c151a7020d90", size = 15890553 }, -] - [[package]] name = "docstring-parser" version = "0.16" @@ -690,78 +536,17 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/7c/e9fcff7623954d86bdc17782036cbf715ecab1bec4847c008557affe1ca8/docstring_parser-0.16-py3-none-any.whl", hash = "sha256:bf0a1387354d3691d102edef7ec124f219ef639982d096e26e3b60aeffa90637", size = 36533 }, ] -[[package]] -name = "docutils" -version = "0.21.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408 }, -] - -[[package]] -name = "easyocr" -version = "1.7.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ninja" }, - { name = "numpy" }, - { name = "opencv-python-headless" }, - { name = "pillow" }, - { name = "pyclipper" }, - { name = "python-bidi" }, - { name = "pyyaml" }, - { name = "scikit-image" }, - { name = "scipy" }, - { name = "shapely" }, - { name = "torch" }, - { name = "torchvision" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/84/4a2cab0e6adde6a85e7ba543862e5fc0250c51f3ac721a078a55cdcff250/easyocr-1.7.2-py3-none-any.whl", hash = "sha256:5be12f9b0e595d443c9c3d10b0542074b50f0ec2d98b141a109cd961fd1c177c", size = 2870178 }, -] - -[[package]] -name = "edge-tts" -version = "6.1.19" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohttp" }, - { name = "certifi" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2b/81/58663476b9afe5ae7f28767d6cadffbf30ed99063a219e213edacecb841b/edge_tts-6.1.19.tar.gz", hash = "sha256:52fdfbaef2b3afee98bbba5e5c6365b5a6156fe78fe4e81e55749f7a563add38", size = 20131 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/52/8d/6b91e2efa7e6f2438888142a66ff053e2bc301b8eddd3cb0fd2452644890/edge_tts-6.1.19-py3-none-any.whl", hash = "sha256:af49ea0539f54b0d76a73bc76cefd9deb2010a11c5ee2a189967e15830a6ba37", size = 22125 }, -] - -[[package]] -name = "elevenlabs" -version = "1.59.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "httpx" }, - { name = "pydantic" }, - { name = "pydantic-core" }, - { name = "requests" }, - { name = "typing-extensions" }, - { name = "websockets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/73/5f/01197145be5be258abdce254010eb300868b85fbf6cf1c6c1538a68caef4/elevenlabs-1.59.0.tar.gz", hash = "sha256:16e735bd594e86d415dd445d249c8cc28b09996cfd627fbc10102c0a84698859", size = 200549 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/1f/eaf5dc72edad9124f16daf36b9226c57893e21280d25e94b6b5c7011c86b/elevenlabs-1.59.0-py3-none-any.whl", hash = "sha256:468145db81a0bc867708b4a8619699f75583e9481b395ec1339d0b443da771ed", size = 523205 }, -] - [[package]] name = "esperanto" -version = "2.1.1" +version = "2.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx" }, { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a4/1b/4ea384d03a972cfdfecb018edbf5ed378b8a1bcb9749f7c9d8c9794c192f/esperanto-2.1.1.tar.gz", hash = "sha256:3bd4c1eb833c6095889f3e7de733c5f5f92b739519919f1bc8fe0487f6211794", size = 3060155 } +sdist = { url = "https://files.pythonhosted.org/packages/f4/c3/6594c9e25af0c93a633b212392f979742491eca4782f071e82b33d8c1510/esperanto-2.3.3.tar.gz", hash = "sha256:3df64556be480a93c1327e4796d57042d0b519356128de374e0e00fa91f4b307", size = 455487 } wheels = [ - { url = "https://files.pythonhosted.org/packages/bc/e1/677d733e4bdfe75e3d155b4dd13b438477ebc6fb89fa495187fc9f9946c5/esperanto-2.1.1-py3-none-any.whl", hash = "sha256:08095c2947a4a7bf97519312d710cf8bb4ba17608e105d2ff7e2c02735a1f3e2", size = 87681 }, + { url = "https://files.pythonhosted.org/packages/10/2c/5db4447f94f71a97e2d238fe8f1320ca9fb238ae7e34bc608868127ad0c6/esperanto-2.3.3-py3-none-any.whl", hash = "sha256:0fe3827d2f9aa8eb311948c7f609ab7f7d34f7fd7f6ec977e37fa0606fc5ac2b", size = 113492 }, ] [[package]] @@ -773,15 +558,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059 }, ] -[[package]] -name = "execnet" -version = "2.1.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bb/ff/b4c0dc78fbe20c3e59c0c7334de0c27eb4001a2b2017999af398bf730817/execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3", size = 166524 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/09/2aea36ff60d16dd8879bdb2f5b3ee0ba8d08cbbdcdfe870e695ce3784385/execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc", size = 40612 }, -] - [[package]] name = "executing" version = "2.2.0" @@ -792,19 +568,18 @@ wheels = [ ] [[package]] -name = "fastjsonschema" -version = "2.21.1" +name = "fastapi" +version = "0.116.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924 }, +dependencies = [ + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/d7/6c8b3bfe33eeffa208183ec037fee0cce9f7f024089ab1c5d12ef04bd27c/fastapi-0.116.1.tar.gz", hash = "sha256:ed52cbf946abfd70c5a0dccb24673f0670deeb517a88b3544d03c2a6bf283143", size = 296485 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl", hash = "sha256:c46ac7c312df840f0c9e220f7964bada936781bc4e2e6eb71f1c4d7553786565", size = 95631 }, ] - -[[package]] -name = "ffmpeg" -version = "1.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f0/cc/3b7408b8ecf7c1d20ad480c3eaed7619857bf1054b690226e906fdf14258/ffmpeg-1.4.tar.gz", hash = "sha256:6931692c890ff21d39938433c2189747815dca0c60ddc7f9bb97f199dba0b5b9", size = 5055 } [[package]] name = "filelock" @@ -826,7 +601,7 @@ wheels = [ [[package]] name = "firecrawl-py" -version = "2.8.0" +version = "2.15.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp" }, @@ -836,52 +611,48 @@ dependencies = [ { name = "requests" }, { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/11/83/64127a0faafb027c2870c3919aae13fd6f8f8066d000bea93c880ab9772a/firecrawl_py-2.8.0.tar.gz", hash = "sha256:657795b6ddd63f0bd38b38bf0571187e0a66becda23d97c032801895257403c9", size = 37941 } +sdist = { url = "https://files.pythonhosted.org/packages/d6/c7/f9f41de0cbe0e90c1e04470b7deeebd73f7bf7cc009d21d57b8d0d339710/firecrawl_py-2.15.0.tar.gz", hash = "sha256:8bc8eea586f1fc81bac8692faa34f362050ff8045298b71d04140239c843349b", size = 39869 } wheels = [ - { url = "https://files.pythonhosted.org/packages/74/e6/e69bd2156856f2b1849244ca3b1d993676175b16acbf704ad85580ebaa3c/firecrawl_py-2.8.0-py3-none-any.whl", hash = "sha256:f2e148086aa1ca42f603a56009577b4f66a2c23893eaa71f7c9c0082b4fdcf60", size = 173118 }, + { url = "https://files.pythonhosted.org/packages/fb/69/bd42f86256158913dd573734ca1f1e928692da88508bf1c8da170c9c7027/firecrawl_py-2.15.0-py3-none-any.whl", hash = "sha256:6e4c53f029fe4784854549cf2760a7ea6a7faa2a098ce9fd49dd85e2f7004186", size = 75435 }, ] [[package]] name = "frozenlist" -version = "1.7.0" +version = "1.5.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/79/b1/b64018016eeb087db503b038296fd782586432b9c077fc5c7839e9cb6ef6/frozenlist-1.7.0.tar.gz", hash = "sha256:2e310d81923c2437ea8670467121cc3e9b0f76d3043cc1d2331d56c7fb7a3a8f", size = 45078 } +sdist = { url = "https://files.pythonhosted.org/packages/8f/ed/0f4cec13a93c02c47ec32d81d11c0c1efbadf4a471e3f3ce7cad366cbbd3/frozenlist-1.5.0.tar.gz", hash = "sha256:81d5af29e61b9c8348e876d442253723928dce6433e0e76cd925cd83f1b4b817", size = 39930 } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/7e/803dde33760128acd393a27eb002f2020ddb8d99d30a44bfbaab31c5f08a/frozenlist-1.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aa51e147a66b2d74de1e6e2cf5921890de6b0f4820b257465101d7f37b49fb5a", size = 82251 }, - { url = "https://files.pythonhosted.org/packages/75/a9/9c2c5760b6ba45eae11334db454c189d43d34a4c0b489feb2175e5e64277/frozenlist-1.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9b35db7ce1cd71d36ba24f80f0c9e7cff73a28d7a74e91fe83e23d27c7828750", size = 48183 }, - { url = "https://files.pythonhosted.org/packages/47/be/4038e2d869f8a2da165f35a6befb9158c259819be22eeaf9c9a8f6a87771/frozenlist-1.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34a69a85e34ff37791e94542065c8416c1afbf820b68f720452f636d5fb990cd", size = 47107 }, - { url = "https://files.pythonhosted.org/packages/79/26/85314b8a83187c76a37183ceed886381a5f992975786f883472fcb6dc5f2/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a646531fa8d82c87fe4bb2e596f23173caec9185bfbca5d583b4ccfb95183e2", size = 237333 }, - { url = "https://files.pythonhosted.org/packages/1f/fd/e5b64f7d2c92a41639ffb2ad44a6a82f347787abc0c7df5f49057cf11770/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:79b2ffbba483f4ed36a0f236ccb85fbb16e670c9238313709638167670ba235f", size = 231724 }, - { url = "https://files.pythonhosted.org/packages/20/fb/03395c0a43a5976af4bf7534759d214405fbbb4c114683f434dfdd3128ef/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a26f205c9ca5829cbf82bb2a84b5c36f7184c4316617d7ef1b271a56720d6b30", size = 245842 }, - { url = "https://files.pythonhosted.org/packages/d0/15/c01c8e1dffdac5d9803507d824f27aed2ba76b6ed0026fab4d9866e82f1f/frozenlist-1.7.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bcacfad3185a623fa11ea0e0634aac7b691aa925d50a440f39b458e41c561d98", size = 239767 }, - { url = "https://files.pythonhosted.org/packages/14/99/3f4c6fe882c1f5514b6848aa0a69b20cb5e5d8e8f51a339d48c0e9305ed0/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:72c1b0fe8fe451b34f12dce46445ddf14bd2a5bcad7e324987194dc8e3a74c86", size = 224130 }, - { url = "https://files.pythonhosted.org/packages/4d/83/220a374bd7b2aeba9d0725130665afe11de347d95c3620b9b82cc2fcab97/frozenlist-1.7.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61d1a5baeaac6c0798ff6edfaeaa00e0e412d49946c53fae8d4b8e8b3566c4ae", size = 235301 }, - { url = "https://files.pythonhosted.org/packages/03/3c/3e3390d75334a063181625343e8daab61b77e1b8214802cc4e8a1bb678fc/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7edf5c043c062462f09b6820de9854bf28cc6cc5b6714b383149745e287181a8", size = 234606 }, - { url = "https://files.pythonhosted.org/packages/23/1e/58232c19608b7a549d72d9903005e2d82488f12554a32de2d5fb59b9b1ba/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d50ac7627b3a1bd2dcef6f9da89a772694ec04d9a61b66cf87f7d9446b4a0c31", size = 248372 }, - { url = "https://files.pythonhosted.org/packages/c0/a4/e4a567e01702a88a74ce8a324691e62a629bf47d4f8607f24bf1c7216e7f/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ce48b2fece5aeb45265bb7a58259f45027db0abff478e3077e12b05b17fb9da7", size = 229860 }, - { url = "https://files.pythonhosted.org/packages/73/a6/63b3374f7d22268b41a9db73d68a8233afa30ed164c46107b33c4d18ecdd/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:fe2365ae915a1fafd982c146754e1de6ab3478def8a59c86e1f7242d794f97d5", size = 245893 }, - { url = "https://files.pythonhosted.org/packages/6d/eb/d18b3f6e64799a79673c4ba0b45e4cfbe49c240edfd03a68be20002eaeaa/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:45a6f2fdbd10e074e8814eb98b05292f27bad7d1883afbe009d96abdcf3bc898", size = 246323 }, - { url = "https://files.pythonhosted.org/packages/5a/f5/720f3812e3d06cd89a1d5db9ff6450088b8f5c449dae8ffb2971a44da506/frozenlist-1.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:21884e23cffabb157a9dd7e353779077bf5b8f9a58e9b262c6caad2ef5f80a56", size = 233149 }, - { url = "https://files.pythonhosted.org/packages/69/68/03efbf545e217d5db8446acfd4c447c15b7c8cf4dbd4a58403111df9322d/frozenlist-1.7.0-cp311-cp311-win32.whl", hash = "sha256:284d233a8953d7b24f9159b8a3496fc1ddc00f4db99c324bd5fb5f22d8698ea7", size = 39565 }, - { url = "https://files.pythonhosted.org/packages/58/17/fe61124c5c333ae87f09bb67186d65038834a47d974fc10a5fadb4cc5ae1/frozenlist-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:387cbfdcde2f2353f19c2f66bbb52406d06ed77519ac7ee21be0232147c2592d", size = 44019 }, - { url = "https://files.pythonhosted.org/packages/ef/a2/c8131383f1e66adad5f6ecfcce383d584ca94055a34d683bbb24ac5f2f1c/frozenlist-1.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3dbf9952c4bb0e90e98aec1bd992b3318685005702656bc6f67c1a32b76787f2", size = 81424 }, - { url = "https://files.pythonhosted.org/packages/4c/9d/02754159955088cb52567337d1113f945b9e444c4960771ea90eb73de8db/frozenlist-1.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f5906d3359300b8a9bb194239491122e6cf1444c2efb88865426f170c262cdb", size = 47952 }, - { url = "https://files.pythonhosted.org/packages/01/7a/0046ef1bd6699b40acd2067ed6d6670b4db2f425c56980fa21c982c2a9db/frozenlist-1.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3dabd5a8f84573c8d10d8859a50ea2dec01eea372031929871368c09fa103478", size = 46688 }, - { url = "https://files.pythonhosted.org/packages/d6/a2/a910bafe29c86997363fb4c02069df4ff0b5bc39d33c5198b4e9dd42d8f8/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa57daa5917f1738064f302bf2626281a1cb01920c32f711fbc7bc36111058a8", size = 243084 }, - { url = "https://files.pythonhosted.org/packages/64/3e/5036af9d5031374c64c387469bfcc3af537fc0f5b1187d83a1cf6fab1639/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c193dda2b6d49f4c4398962810fa7d7c78f032bf45572b3e04dd5249dff27e08", size = 233524 }, - { url = "https://files.pythonhosted.org/packages/06/39/6a17b7c107a2887e781a48ecf20ad20f1c39d94b2a548c83615b5b879f28/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfe2b675cf0aaa6d61bf8fbffd3c274b3c9b7b1623beb3809df8a81399a4a9c4", size = 248493 }, - { url = "https://files.pythonhosted.org/packages/be/00/711d1337c7327d88c44d91dd0f556a1c47fb99afc060ae0ef66b4d24793d/frozenlist-1.7.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8fc5d5cda37f62b262405cf9652cf0856839c4be8ee41be0afe8858f17f4c94b", size = 244116 }, - { url = "https://files.pythonhosted.org/packages/24/fe/74e6ec0639c115df13d5850e75722750adabdc7de24e37e05a40527ca539/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0d5ce521d1dd7d620198829b87ea002956e4319002ef0bc8d3e6d045cb4646e", size = 224557 }, - { url = "https://files.pythonhosted.org/packages/8d/db/48421f62a6f77c553575201e89048e97198046b793f4a089c79a6e3268bd/frozenlist-1.7.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:488d0a7d6a0008ca0db273c542098a0fa9e7dfaa7e57f70acef43f32b3f69dca", size = 241820 }, - { url = "https://files.pythonhosted.org/packages/1d/fa/cb4a76bea23047c8462976ea7b7a2bf53997a0ca171302deae9d6dd12096/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:15a7eaba63983d22c54d255b854e8108e7e5f3e89f647fc854bd77a237e767df", size = 236542 }, - { url = "https://files.pythonhosted.org/packages/5d/32/476a4b5cfaa0ec94d3f808f193301debff2ea42288a099afe60757ef6282/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1eaa7e9c6d15df825bf255649e05bd8a74b04a4d2baa1ae46d9c2d00b2ca2cb5", size = 249350 }, - { url = "https://files.pythonhosted.org/packages/8d/ba/9a28042f84a6bf8ea5dbc81cfff8eaef18d78b2a1ad9d51c7bc5b029ad16/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4389e06714cfa9d47ab87f784a7c5be91d3934cd6e9a7b85beef808297cc025", size = 225093 }, - { url = "https://files.pythonhosted.org/packages/bc/29/3a32959e68f9cf000b04e79ba574527c17e8842e38c91d68214a37455786/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:73bd45e1488c40b63fe5a7df892baf9e2a4d4bb6409a2b3b78ac1c6236178e01", size = 245482 }, - { url = "https://files.pythonhosted.org/packages/80/e8/edf2f9e00da553f07f5fa165325cfc302dead715cab6ac8336a5f3d0adc2/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99886d98e1643269760e5fe0df31e5ae7050788dd288947f7f007209b8c33f08", size = 249590 }, - { url = "https://files.pythonhosted.org/packages/1c/80/9a0eb48b944050f94cc51ee1c413eb14a39543cc4f760ed12657a5a3c45a/frozenlist-1.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:290a172aae5a4c278c6da8a96222e6337744cd9c77313efe33d5670b9f65fc43", size = 237785 }, - { url = "https://files.pythonhosted.org/packages/f3/74/87601e0fb0369b7a2baf404ea921769c53b7ae00dee7dcfe5162c8c6dbf0/frozenlist-1.7.0-cp312-cp312-win32.whl", hash = "sha256:426c7bc70e07cfebc178bc4c2bf2d861d720c4fff172181eeb4a4c41d4ca2ad3", size = 39487 }, - { url = "https://files.pythonhosted.org/packages/0b/15/c026e9a9fc17585a9d461f65d8593d281fedf55fbf7eb53f16c6df2392f9/frozenlist-1.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:563b72efe5da92e02eb68c59cb37205457c977aa7a449ed1b37e6939e5c47c6a", size = 43874 }, - { url = "https://files.pythonhosted.org/packages/ee/45/b82e3c16be2182bff01179db177fe144d58b5dc787a7d4492c6ed8b9317f/frozenlist-1.7.0-py3-none-any.whl", hash = "sha256:9a5af342e34f7e97caf8c995864c7a396418ae2859cc6fdf1b1073020d516a7e", size = 13106 }, + { url = "https://files.pythonhosted.org/packages/79/43/0bed28bf5eb1c9e4301003b74453b8e7aa85fb293b31dde352aac528dafc/frozenlist-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fd74520371c3c4175142d02a976aee0b4cb4a7cc912a60586ffd8d5929979b30", size = 94987 }, + { url = "https://files.pythonhosted.org/packages/bb/bf/b74e38f09a246e8abbe1e90eb65787ed745ccab6eaa58b9c9308e052323d/frozenlist-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2f3f7a0fbc219fb4455264cae4d9f01ad41ae6ee8524500f381de64ffaa077d5", size = 54584 }, + { url = "https://files.pythonhosted.org/packages/2c/31/ab01375682f14f7613a1ade30149f684c84f9b8823a4391ed950c8285656/frozenlist-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f47c9c9028f55a04ac254346e92977bf0f166c483c74b4232bee19a6697e4778", size = 52499 }, + { url = "https://files.pythonhosted.org/packages/98/a8/d0ac0b9276e1404f58fec3ab6e90a4f76b778a49373ccaf6a563f100dfbc/frozenlist-1.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0996c66760924da6e88922756d99b47512a71cfd45215f3570bf1e0b694c206a", size = 276357 }, + { url = "https://files.pythonhosted.org/packages/ad/c9/c7761084fa822f07dac38ac29f841d4587570dd211e2262544aa0b791d21/frozenlist-1.5.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a2fe128eb4edeabe11896cb6af88fca5346059f6c8d807e3b910069f39157869", size = 287516 }, + { url = "https://files.pythonhosted.org/packages/a1/ff/cd7479e703c39df7bdab431798cef89dc75010d8aa0ca2514c5b9321db27/frozenlist-1.5.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a8ea951bbb6cacd492e3948b8da8c502a3f814f5d20935aae74b5df2b19cf3d", size = 283131 }, + { url = "https://files.pythonhosted.org/packages/59/a0/370941beb47d237eca4fbf27e4e91389fd68699e6f4b0ebcc95da463835b/frozenlist-1.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:de537c11e4aa01d37db0d403b57bd6f0546e71a82347a97c6a9f0dcc532b3a45", size = 261320 }, + { url = "https://files.pythonhosted.org/packages/b8/5f/c10123e8d64867bc9b4f2f510a32042a306ff5fcd7e2e09e5ae5100ee333/frozenlist-1.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c2623347b933fcb9095841f1cc5d4ff0b278addd743e0e966cb3d460278840d", size = 274877 }, + { url = "https://files.pythonhosted.org/packages/fa/79/38c505601ae29d4348f21706c5d89755ceded02a745016ba2f58bd5f1ea6/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cee6798eaf8b1416ef6909b06f7dc04b60755206bddc599f52232606e18179d3", size = 269592 }, + { url = "https://files.pythonhosted.org/packages/19/e2/39f3a53191b8204ba9f0bb574b926b73dd2efba2a2b9d2d730517e8f7622/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f5f9da7f5dbc00a604fe74aa02ae7c98bcede8a3b8b9666f9f86fc13993bc71a", size = 265934 }, + { url = "https://files.pythonhosted.org/packages/d5/c9/3075eb7f7f3a91f1a6b00284af4de0a65a9ae47084930916f5528144c9dd/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:90646abbc7a5d5c7c19461d2e3eeb76eb0b204919e6ece342feb6032c9325ae9", size = 283859 }, + { url = "https://files.pythonhosted.org/packages/05/f5/549f44d314c29408b962fa2b0e69a1a67c59379fb143b92a0a065ffd1f0f/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:bdac3c7d9b705d253b2ce370fde941836a5f8b3c5c2b8fd70940a3ea3af7f4f2", size = 287560 }, + { url = "https://files.pythonhosted.org/packages/9d/f8/cb09b3c24a3eac02c4c07a9558e11e9e244fb02bf62c85ac2106d1eb0c0b/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03d33c2ddbc1816237a67f66336616416e2bbb6beb306e5f890f2eb22b959cdf", size = 277150 }, + { url = "https://files.pythonhosted.org/packages/37/48/38c2db3f54d1501e692d6fe058f45b6ad1b358d82cd19436efab80cfc965/frozenlist-1.5.0-cp311-cp311-win32.whl", hash = "sha256:237f6b23ee0f44066219dae14c70ae38a63f0440ce6750f868ee08775073f942", size = 45244 }, + { url = "https://files.pythonhosted.org/packages/ca/8c/2ddffeb8b60a4bce3b196c32fcc30d8830d4615e7b492ec2071da801b8ad/frozenlist-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:0cc974cc93d32c42e7b0f6cf242a6bd941c57c61b618e78b6c0a96cb72788c1d", size = 51634 }, + { url = "https://files.pythonhosted.org/packages/79/73/fa6d1a96ab7fd6e6d1c3500700963eab46813847f01ef0ccbaa726181dd5/frozenlist-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:31115ba75889723431aa9a4e77d5f398f5cf976eea3bdf61749731f62d4a4a21", size = 94026 }, + { url = "https://files.pythonhosted.org/packages/ab/04/ea8bf62c8868b8eada363f20ff1b647cf2e93377a7b284d36062d21d81d1/frozenlist-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7437601c4d89d070eac8323f121fcf25f88674627505334654fd027b091db09d", size = 54150 }, + { url = "https://files.pythonhosted.org/packages/d0/9a/8e479b482a6f2070b26bda572c5e6889bb3ba48977e81beea35b5ae13ece/frozenlist-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7948140d9f8ece1745be806f2bfdf390127cf1a763b925c4a805c603df5e697e", size = 51927 }, + { url = "https://files.pythonhosted.org/packages/e3/12/2aad87deb08a4e7ccfb33600871bbe8f0e08cb6d8224371387f3303654d7/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feeb64bc9bcc6b45c6311c9e9b99406660a9c05ca8a5b30d14a78555088b0b3a", size = 282647 }, + { url = "https://files.pythonhosted.org/packages/77/f2/07f06b05d8a427ea0060a9cef6e63405ea9e0d761846b95ef3fb3be57111/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:683173d371daad49cffb8309779e886e59c2f369430ad28fe715f66d08d4ab1a", size = 289052 }, + { url = "https://files.pythonhosted.org/packages/bd/9f/8bf45a2f1cd4aa401acd271b077989c9267ae8463e7c8b1eb0d3f561b65e/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7d57d8f702221405a9d9b40f9da8ac2e4a1a8b5285aac6100f3393675f0a85ee", size = 291719 }, + { url = "https://files.pythonhosted.org/packages/41/d1/1f20fd05a6c42d3868709b7604c9f15538a29e4f734c694c6bcfc3d3b935/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c72000fbcc35b129cb09956836c7d7abf78ab5416595e4857d1cae8d6251a6", size = 267433 }, + { url = "https://files.pythonhosted.org/packages/af/f2/64b73a9bb86f5a89fb55450e97cd5c1f84a862d4ff90d9fd1a73ab0f64a5/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000a77d6034fbad9b6bb880f7ec073027908f1b40254b5d6f26210d2dab1240e", size = 283591 }, + { url = "https://files.pythonhosted.org/packages/29/e2/ffbb1fae55a791fd6c2938dd9ea779509c977435ba3940b9f2e8dc9d5316/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d7f5a50342475962eb18b740f3beecc685a15b52c91f7d975257e13e029eca9", size = 273249 }, + { url = "https://files.pythonhosted.org/packages/2e/6e/008136a30798bb63618a114b9321b5971172a5abddff44a100c7edc5ad4f/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:87f724d055eb4785d9be84e9ebf0f24e392ddfad00b3fe036e43f489fafc9039", size = 271075 }, + { url = "https://files.pythonhosted.org/packages/ae/f0/4e71e54a026b06724cec9b6c54f0b13a4e9e298cc8db0f82ec70e151f5ce/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6e9080bb2fb195a046e5177f10d9d82b8a204c0736a97a153c2466127de87784", size = 285398 }, + { url = "https://files.pythonhosted.org/packages/4d/36/70ec246851478b1c0b59f11ef8ade9c482ff447c1363c2bd5fad45098b12/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b93d7aaa36c966fa42efcaf716e6b3900438632a626fb09c049f6a2f09fc631", size = 294445 }, + { url = "https://files.pythonhosted.org/packages/37/e0/47f87544055b3349b633a03c4d94b405956cf2437f4ab46d0928b74b7526/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:52ef692a4bc60a6dd57f507429636c2af8b6046db8b31b18dac02cbc8f507f7f", size = 280569 }, + { url = "https://files.pythonhosted.org/packages/f9/7c/490133c160fb6b84ed374c266f42800e33b50c3bbab1652764e6e1fc498a/frozenlist-1.5.0-cp312-cp312-win32.whl", hash = "sha256:29d94c256679247b33a3dc96cce0f93cbc69c23bf75ff715919332fdbb6a32b8", size = 44721 }, + { url = "https://files.pythonhosted.org/packages/b1/56/4e45136ffc6bdbfa68c29ca56ef53783ef4c2fd395f7cbf99a2624aa9aaa/frozenlist-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:8969190d709e7c48ea386db202d708eb94bdb29207a1f269bab1196ce0dcca1f", size = 51329 }, + { url = "https://files.pythonhosted.org/packages/c6/c8/a5be5b7550c10858fcf9b0ea054baccab474da77d37f1e828ce043a3a5d4/frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3", size = 11901 }, ] [[package]] @@ -893,15 +664,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/bb/61/78c7b3851add1481b048b5fdc29067397a1784e2910592bc81bb3f608635/fsspec-2025.5.1-py3-none-any.whl", hash = "sha256:24d3a2e663d5fc735ab256263c4075f374a174c3410c0b25e5bd1970bceaa462", size = 199052 }, ] -[[package]] -name = "fuzzywuzzy" -version = "0.18.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/11/4b/0a002eea91be6048a2b5d53c5f1b4dafd57ba2e36eea961d05086d7c28ce/fuzzywuzzy-0.18.0.tar.gz", hash = "sha256:45016e92264780e58972dca1b3d939ac864b78437422beecebb3095f8efd00e8", size = 28888 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ff/74f23998ad2f93b945c0309f825be92e04e0348e062026998b5eefef4c33/fuzzywuzzy-0.18.0-py2.py3-none-any.whl", hash = "sha256:928244b28db720d1e0ee7587acf660ea49d7e4c632569cad4f1cd7e68a5f0993", size = 18272 }, -] - [[package]] name = "gitdb" version = "4.0.12" @@ -928,7 +690,7 @@ wheels = [ [[package]] name = "google-ai-generativelanguage" -version = "0.6.15" +version = "0.6.18" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "google-api-core", extra = ["grpc"] }, @@ -936,9 +698,9 @@ dependencies = [ { name = "proto-plus" }, { name = "protobuf" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/11/d1/48fe5d7a43d278e9f6b5ada810b0a3530bbeac7ed7fcbcd366f932f05316/google_ai_generativelanguage-0.6.15.tar.gz", hash = "sha256:8f6d9dc4c12b065fe2d0289026171acea5183ebf2d0b11cefe12f3821e159ec3", size = 1375443 } +sdist = { url = "https://files.pythonhosted.org/packages/eb/77/3e89a4c4200135eac74eca2f6c9153127e3719a825681ad55f5a4a58b422/google_ai_generativelanguage-0.6.18.tar.gz", hash = "sha256:274ba9fcf69466ff64e971d565884434388e523300afd468fc8e3033cd8e606e", size = 1444757 } wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/a3/67b8a6ff5001a1d8864922f2d6488dc2a14367ceb651bc3f09a947f2f306/google_ai_generativelanguage-0.6.15-py3-none-any.whl", hash = "sha256:5a03ef86377aa184ffef3662ca28f19eeee158733e45d7947982eb953c6ebb6c", size = 1327356 }, + { url = "https://files.pythonhosted.org/packages/e5/77/ca2889903a2d93b3072a49056d48b3f55410219743e338a1d7f94dc6455e/google_ai_generativelanguage-0.6.18-py3-none-any.whl", hash = "sha256:13d8174fea90b633f520789d32df7b422058fd5883b022989c349f1017db7fcf", size = 1372256 }, ] [[package]] @@ -963,22 +725,6 @@ grpc = [ { name = "grpcio-status" }, ] -[[package]] -name = "google-api-python-client" -version = "2.172.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core" }, - { name = "google-auth" }, - { name = "google-auth-httplib2" }, - { name = "httplib2" }, - { name = "uritemplate" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/02/69/c0cec6be5878d4de161f64096edb3d4a2d1a838f036b8425ea8358d0dfb3/google_api_python_client-2.172.0.tar.gz", hash = "sha256:dcb3b7e067154b2aa41f1776cf86584a5739c0ac74e6ff46fc665790dca0e6a6", size = 13074841 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/15/fc/8850ccf21c5df43faeaf8bba8c4149ee880b41b8dc7066e3259bcfd921ca/google_api_python_client-2.172.0-py3-none-any.whl", hash = "sha256:9f1b9a268d5dc1228207d246c673d3a09ee211b41a11521d38d9212aeaa43af7", size = 13595800 }, -] - [[package]] name = "google-auth" version = "2.40.3" @@ -993,22 +739,9 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/17/63/b19553b658a1692443c62bd07e5868adaa0ad746a0751ba62c59568cd45b/google_auth-2.40.3-py2.py3-none-any.whl", hash = "sha256:1370d4593e86213563547f97a92752fc658456fe4514c809544f330fed45a7ca", size = 216137 }, ] -[[package]] -name = "google-auth-httplib2" -version = "0.2.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-auth" }, - { name = "httplib2" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/56/be/217a598a818567b28e859ff087f347475c807a5649296fb5a817c58dacef/google-auth-httplib2-0.2.0.tar.gz", hash = "sha256:38aa7badf48f974f1eb9861794e9c0cb2a0511a4ec0679b1f886d108f5640e05", size = 10842 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/be/8a/fe34d2f3f9470a27b01c9e76226965863f153d5fbe276f83608562e49c04/google_auth_httplib2-0.2.0-py2.py3-none-any.whl", hash = "sha256:b65a0a2123300dd71281a7bf6e64d65a0759287df52729bdd1ae2e47dc311a3d", size = 9253 }, -] - [[package]] name = "google-cloud-aiplatform" -version = "1.97.0" +version = "1.103.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "docstring-parser" }, @@ -1025,9 +758,9 @@ dependencies = [ { name = "shapely" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9b/ea/38224d2972e16c82ee16c13407e647586e25671bd2f75d4455491c678c92/google_cloud_aiplatform-1.97.0.tar.gz", hash = "sha256:01277ac5648abe7d2af688b123d7d050c1a34922e9f4297e51e44d165cb79b45", size = 9229557 } +sdist = { url = "https://files.pythonhosted.org/packages/2a/f1/deec517e3b10992d3b07e729f2682303c4c999499a1819fde90a57b44e48/google_cloud_aiplatform-1.103.0.tar.gz", hash = "sha256:0d0c0db3bde6182097f4db8ddcbfb2ab382009458cf594c09cfb4406896b9795", size = 9449712 } wheels = [ - { url = "https://files.pythonhosted.org/packages/9a/b8/f9ca10a648bc2596e904c30270c49e72528e2b3b583d886eeeec5080b27d/google_cloud_aiplatform-1.97.0-py2.py3-none-any.whl", hash = "sha256:4db9455308110b1e8c1b587bd3ff34449fa459fda45c4466b9b2d9ae259a7af6", size = 7687924 }, + { url = "https://files.pythonhosted.org/packages/3a/8e/0779ce9d733c9073a00e2815c82e444f60332c2aac36148f62e2f3418b78/google_cloud_aiplatform-1.103.0-py2.py3-none-any.whl", hash = "sha256:bc14d90caed44580192ad8b60cf74c5a7089562a0dfa6425cad163971d3ae759", size = 7854846 }, ] [[package]] @@ -1094,21 +827,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/94/6db383d8ee1adf45dc6c73477152b82731fa4c4a46d9c1932cc8757e0fd4/google_cloud_storage-2.19.0-py2.py3-none-any.whl", hash = "sha256:aeb971b5c29cf8ab98445082cbfe7b161a1f48ed275822f59ed3f1524ea54fba", size = 131787 }, ] -[[package]] -name = "google-cloud-texttospeech" -version = "2.27.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3b/65/0873b430c2ad885bde9649bfcdc9e87dca0ad400da4ff1495f62911baa36/google_cloud_texttospeech-2.27.0.tar.gz", hash = "sha256:94a382c95b7cc58efd2505a24c2968e2614fc6bdf9d76fb9a819d4ed29ae188e", size = 182332 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d8/40/1560257fb77b601c0801b370411e0b849b278a90e6232b46c5b84489fb67/google_cloud_texttospeech-2.27.0-py3-none-any.whl", hash = "sha256:0f7c5fe05281beb6d005ea191f61c913085e8439e5ffd2d5d21e29d106150b54", size = 189408 }, -] - [[package]] name = "google-crc32c" version = "1.7.1" @@ -1131,35 +849,20 @@ wheels = [ [[package]] name = "google-genai" -version = "1.2.0" +version = "1.20.0" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "anyio" }, { name = "google-auth" }, + { name = "httpx" }, { name = "pydantic" }, { name = "requests" }, { name = "typing-extensions" }, { name = "websockets" }, ] +sdist = { url = "https://files.pythonhosted.org/packages/19/12/ad9f08be2ca85122ca50ac69ae70454f18a3c7d840bcc4ed43f517ab47be/google_genai-1.20.0.tar.gz", hash = "sha256:dccca78f765233844b1bd4f1f7a2237d9a76fe6038cf9aa72c0cd991e3c107b5", size = 201550 } wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/ed/985f2d2e2b5fbd912ab0fdb11d6dc48c22553a6c4edffabb8146d53b974a/google_genai-1.2.0-py3-none-any.whl", hash = "sha256:609d61bee73f1a6ae5b47e9c7dd4b469d50318f050c5ceacf835b0f80f79d2d9", size = 130744 }, -] - -[[package]] -name = "google-generativeai" -version = "0.8.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-ai-generativelanguage" }, - { name = "google-api-core" }, - { name = "google-api-python-client" }, - { name = "google-auth" }, - { name = "protobuf" }, - { name = "pydantic" }, - { name = "tqdm" }, - { name = "typing-extensions" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/6e/40/c42ff9ded9f09ec9392879a8e6538a00b2dc185e834a3392917626255419/google_generativeai-0.8.5-py3-none-any.whl", hash = "sha256:22b420817fb263f8ed520b33285f45976d5b21e904da32b80d4fd20c055123a2", size = 155427 }, + { url = "https://files.pythonhosted.org/packages/b9/b4/08f3ea414060a7e7d4436c08bb22d03dabef74cc05ef13ef8cd846156d5b/google_genai-1.20.0-py3-none-any.whl", hash = "sha256:ccd61d6ebcb14f5c778b817b8010e3955ae4f6ddfeaabf65f42f6d5e3e5a8125", size = 203039 }, ] [[package]] @@ -1219,7 +922,7 @@ wheels = [ [[package]] name = "groq" -version = "0.28.0" +version = "0.30.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -1229,9 +932,9 @@ dependencies = [ { name = "sniffio" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d0/7d/bb053ba75357bf5e8c33def63fb31c8b0bb86dce07759a0cd8e3232d2df9/groq-0.28.0.tar.gz", hash = "sha256:65e1cab9184cbb32380d62eca50d6162269c7ec0c77e4cc868069cfe93450f9f", size = 131730 } +sdist = { url = "https://files.pythonhosted.org/packages/a9/b1/72ca20dc9b977b7f604648e8944c77b267bddeb90d8e16bda0cf0e397844/groq-0.30.0.tar.gz", hash = "sha256:919466e48fcbebef08fed3f71debb0f96b0ea8d2ec77842c384aa843019f6e2c", size = 134928 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ac/24/20fc18d1b3e0883aeb24286ca8f26dc1970561b07d9c4412c84561bdf307/groq-0.28.0-py3-none-any.whl", hash = "sha256:c6f86638371c2cba2ca337232e76c8d412e75965ed7e3058d30c9aa5dfe84303", size = 130217 }, + { url = "https://files.pythonhosted.org/packages/19/b8/5b90edf9fbd795597220e3d1b5534d845e69a73ffe1fdeb967443ed2a6cf/groq-0.30.0-py3-none-any.whl", hash = "sha256:6d9609a7778ba56432f45c1bac21b005f02c6c0aca9c1c094e65536f162c1e83", size = 131056 }, ] [[package]] @@ -1250,44 +953,44 @@ wheels = [ [[package]] name = "grpcio" -version = "1.73.0" +version = "1.73.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8e/7b/ca3f561aeecf0c846d15e1b38921a60dffffd5d4113931198fbf455334ee/grpcio-1.73.0.tar.gz", hash = "sha256:3af4c30918a7f0d39de500d11255f8d9da4f30e94a2033e70fe2a720e184bd8e", size = 12786424 } +sdist = { url = "https://files.pythonhosted.org/packages/79/e8/b43b851537da2e2f03fa8be1aef207e5cbfb1a2e014fbb6b40d24c177cd3/grpcio-1.73.1.tar.gz", hash = "sha256:7fce2cd1c0c1116cf3850564ebfc3264fba75d3c74a7414373f1238ea365ef87", size = 12730355 } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/31/9de81fd12f7b27e6af403531b7249d76f743d58e0654e624b3df26a43ce2/grpcio-1.73.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:51036f641f171eebe5fa7aaca5abbd6150f0c338dab3a58f9111354240fe36ec", size = 5363773 }, - { url = "https://files.pythonhosted.org/packages/32/9e/2cb78be357a7f1fc4942b81468ef3c7e5fd3df3ac010540459c10895a57b/grpcio-1.73.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:d12bbb88381ea00bdd92c55aff3da3391fd85bc902c41275c8447b86f036ce0f", size = 10621912 }, - { url = "https://files.pythonhosted.org/packages/59/2f/b43954811a2e218a2761c0813800773ac0ca187b94fd2b8494e8ef232dc8/grpcio-1.73.0-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:483c507c2328ed0e01bc1adb13d1eada05cc737ec301d8e5a8f4a90f387f1790", size = 5807985 }, - { url = "https://files.pythonhosted.org/packages/1b/bf/68e9f47e7ee349ffee712dcd907ee66826cf044f0dec7ab517421e56e857/grpcio-1.73.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c201a34aa960c962d0ce23fe5f423f97e9d4b518ad605eae6d0a82171809caaa", size = 6448218 }, - { url = "https://files.pythonhosted.org/packages/af/dd/38ae43dd58480d609350cf1411fdac5c2ebb243e2c770f6f7aa3773d5e29/grpcio-1.73.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:859f70c8e435e8e1fa060e04297c6818ffc81ca9ebd4940e180490958229a45a", size = 6044343 }, - { url = "https://files.pythonhosted.org/packages/93/44/b6770b55071adb86481f36dae87d332fcad883b7f560bba9a940394ba018/grpcio-1.73.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e2459a27c6886e7e687e4e407778425f3c6a971fa17a16420227bda39574d64b", size = 6135858 }, - { url = "https://files.pythonhosted.org/packages/d3/9f/63de49fcef436932fcf0ffb978101a95c83c177058dbfb56dbf30ab81659/grpcio-1.73.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:e0084d4559ee3dbdcce9395e1bc90fdd0262529b32c417a39ecbc18da8074ac7", size = 6775806 }, - { url = "https://files.pythonhosted.org/packages/4d/67/c11f1953469162e958f09690ec3a9be3fdb29dea7f5661362a664f9d609a/grpcio-1.73.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ef5fff73d5f724755693a464d444ee0a448c6cdfd3c1616a9223f736c622617d", size = 6308413 }, - { url = "https://files.pythonhosted.org/packages/ba/6a/9dd04426337db07f28bd51a986b7a038ba56912c81b5bb1083c17dd63404/grpcio-1.73.0-cp311-cp311-win32.whl", hash = "sha256:965a16b71a8eeef91fc4df1dc40dc39c344887249174053814f8a8e18449c4c3", size = 3678972 }, - { url = "https://files.pythonhosted.org/packages/04/8b/8c0a8a4fdc2e7977d325eafc587c9cf468039693ac23ad707153231d3cb2/grpcio-1.73.0-cp311-cp311-win_amd64.whl", hash = "sha256:b71a7b4483d1f753bbc11089ff0f6fa63b49c97a9cc20552cded3fcad466d23b", size = 4342967 }, - { url = "https://files.pythonhosted.org/packages/9d/4d/e938f3a0e51a47f2ce7e55f12f19f316e7074770d56a7c2765e782ec76bc/grpcio-1.73.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:fb9d7c27089d9ba3746f18d2109eb530ef2a37452d2ff50f5a6696cd39167d3b", size = 5334911 }, - { url = "https://files.pythonhosted.org/packages/13/56/f09c72c43aa8d6f15a71f2c63ebdfac9cf9314363dea2598dc501d8370db/grpcio-1.73.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:128ba2ebdac41e41554d492b82c34586a90ebd0766f8ebd72160c0e3a57b9155", size = 10601460 }, - { url = "https://files.pythonhosted.org/packages/20/e3/85496edc81e41b3c44ebefffc7bce133bb531120066877df0f910eabfa19/grpcio-1.73.0-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:068ecc415f79408d57a7f146f54cdf9f0acb4b301a52a9e563973dc981e82f3d", size = 5759191 }, - { url = "https://files.pythonhosted.org/packages/88/cc/fef74270a6d29f35ad744bfd8e6c05183f35074ff34c655a2c80f3b422b2/grpcio-1.73.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ddc1cfb2240f84d35d559ade18f69dcd4257dbaa5ba0de1a565d903aaab2968", size = 6409961 }, - { url = "https://files.pythonhosted.org/packages/b0/e6/13cfea15e3b8f79c4ae7b676cb21fab70978b0fde1e1d28bb0e073291290/grpcio-1.73.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53007f70d9783f53b41b4cf38ed39a8e348011437e4c287eee7dd1d39d54b2f", size = 6003948 }, - { url = "https://files.pythonhosted.org/packages/c2/ed/b1a36dad4cc0dbf1f83f6d7b58825fefd5cc9ff3a5036e46091335649473/grpcio-1.73.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4dd8d8d092efede7d6f48d695ba2592046acd04ccf421436dd7ed52677a9ad29", size = 6103788 }, - { url = "https://files.pythonhosted.org/packages/e7/c8/d381433d3d46d10f6858126d2d2245ef329e30f3752ce4514c93b95ca6fc/grpcio-1.73.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:70176093d0a95b44d24baa9c034bb67bfe2b6b5f7ebc2836f4093c97010e17fd", size = 6749508 }, - { url = "https://files.pythonhosted.org/packages/87/0a/ff0c31dbd15e63b34320efafac647270aa88c31aa19ff01154a73dc7ce86/grpcio-1.73.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:085ebe876373ca095e24ced95c8f440495ed0b574c491f7f4f714ff794bbcd10", size = 6284342 }, - { url = "https://files.pythonhosted.org/packages/fd/73/f762430c0ba867403b9d6e463afe026bf019bd9206eee753785239719273/grpcio-1.73.0-cp312-cp312-win32.whl", hash = "sha256:cfc556c1d6aef02c727ec7d0016827a73bfe67193e47c546f7cadd3ee6bf1a60", size = 3669319 }, - { url = "https://files.pythonhosted.org/packages/10/8b/3411609376b2830449cf416f457ad9d2aacb7f562e1b90fdd8bdedf26d63/grpcio-1.73.0-cp312-cp312-win_amd64.whl", hash = "sha256:bbf45d59d090bf69f1e4e1594832aaf40aa84b31659af3c5e2c3f6a35202791a", size = 4335596 }, + { url = "https://files.pythonhosted.org/packages/e4/41/921565815e871d84043e73e2c0e748f0318dab6fa9be872cd042778f14a9/grpcio-1.73.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:ba2cea9f7ae4bc21f42015f0ec98f69ae4179848ad744b210e7685112fa507a1", size = 5363853 }, + { url = "https://files.pythonhosted.org/packages/b0/cc/9c51109c71d068e4d474becf5f5d43c9d63038cec1b74112978000fa72f4/grpcio-1.73.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:d74c3f4f37b79e746271aa6cdb3a1d7e4432aea38735542b23adcabaaee0c097", size = 10621476 }, + { url = "https://files.pythonhosted.org/packages/8f/d3/33d738a06f6dbd4943f4d377468f8299941a7c8c6ac8a385e4cef4dd3c93/grpcio-1.73.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:5b9b1805a7d61c9e90541cbe8dfe0a593dfc8c5c3a43fe623701b6a01b01d710", size = 5807903 }, + { url = "https://files.pythonhosted.org/packages/5d/47/36deacd3c967b74e0265f4c608983e897d8bb3254b920f8eafdf60e4ad7e/grpcio-1.73.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3215f69a0670a8cfa2ab53236d9e8026bfb7ead5d4baabe7d7dc11d30fda967", size = 6448172 }, + { url = "https://files.pythonhosted.org/packages/0e/64/12d6dc446021684ee1428ea56a3f3712048a18beeadbdefa06e6f8814a6e/grpcio-1.73.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc5eccfd9577a5dc7d5612b2ba90cca4ad14c6d949216c68585fdec9848befb1", size = 6044226 }, + { url = "https://files.pythonhosted.org/packages/72/4b/6bae2d88a006000f1152d2c9c10ffd41d0131ca1198e0b661101c2e30ab9/grpcio-1.73.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:dc7d7fd520614fce2e6455ba89791458020a39716951c7c07694f9dbae28e9c0", size = 6135690 }, + { url = "https://files.pythonhosted.org/packages/38/64/02c83b5076510784d1305025e93e0d78f53bb6a0213c8c84cfe8a00c5c48/grpcio-1.73.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:105492124828911f85127e4825d1c1234b032cb9d238567876b5515d01151379", size = 6775867 }, + { url = "https://files.pythonhosted.org/packages/42/72/a13ff7ba6c68ccffa35dacdc06373a76c0008fd75777cba84d7491956620/grpcio-1.73.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:610e19b04f452ba6f402ac9aa94eb3d21fbc94553368008af634812c4a85a99e", size = 6308380 }, + { url = "https://files.pythonhosted.org/packages/65/ae/d29d948021faa0070ec33245c1ae354e2aefabd97e6a9a7b6dcf0fb8ef6b/grpcio-1.73.1-cp311-cp311-win32.whl", hash = "sha256:d60588ab6ba0ac753761ee0e5b30a29398306401bfbceffe7d68ebb21193f9d4", size = 3679139 }, + { url = "https://files.pythonhosted.org/packages/af/66/e1bbb0c95ea222947f0829b3db7692c59b59bcc531df84442e413fa983d9/grpcio-1.73.1-cp311-cp311-win_amd64.whl", hash = "sha256:6957025a4608bb0a5ff42abd75bfbb2ed99eda29d5992ef31d691ab54b753643", size = 4342558 }, + { url = "https://files.pythonhosted.org/packages/b8/41/456caf570c55d5ac26f4c1f2db1f2ac1467d5bf3bcd660cba3e0a25b195f/grpcio-1.73.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:921b25618b084e75d424a9f8e6403bfeb7abef074bb6c3174701e0f2542debcf", size = 5334621 }, + { url = "https://files.pythonhosted.org/packages/2a/c2/9a15e179e49f235bb5e63b01590658c03747a43c9775e20c4e13ca04f4c4/grpcio-1.73.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:277b426a0ed341e8447fbf6c1d6b68c952adddf585ea4685aa563de0f03df887", size = 10601131 }, + { url = "https://files.pythonhosted.org/packages/0c/1d/1d39e90ef6348a0964caa7c5c4d05f3bae2c51ab429eb7d2e21198ac9b6d/grpcio-1.73.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:96c112333309493c10e118d92f04594f9055774757f5d101b39f8150f8c25582", size = 5759268 }, + { url = "https://files.pythonhosted.org/packages/8a/2b/2dfe9ae43de75616177bc576df4c36d6401e0959833b2e5b2d58d50c1f6b/grpcio-1.73.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f48e862aed925ae987eb7084409a80985de75243389dc9d9c271dd711e589918", size = 6409791 }, + { url = "https://files.pythonhosted.org/packages/6e/66/e8fe779b23b5a26d1b6949e5c70bc0a5fd08f61a6ec5ac7760d589229511/grpcio-1.73.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83a6c2cce218e28f5040429835fa34a29319071079e3169f9543c3fbeff166d2", size = 6003728 }, + { url = "https://files.pythonhosted.org/packages/a9/39/57a18fcef567784108c4fc3f5441cb9938ae5a51378505aafe81e8e15ecc/grpcio-1.73.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:65b0458a10b100d815a8426b1442bd17001fdb77ea13665b2f7dc9e8587fdc6b", size = 6103364 }, + { url = "https://files.pythonhosted.org/packages/c5/46/28919d2aa038712fc399d02fa83e998abd8c1f46c2680c5689deca06d1b2/grpcio-1.73.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:0a9f3ea8dce9eae9d7cb36827200133a72b37a63896e0e61a9d5ec7d61a59ab1", size = 6749194 }, + { url = "https://files.pythonhosted.org/packages/3d/56/3898526f1fad588c5d19a29ea0a3a4996fb4fa7d7c02dc1be0c9fd188b62/grpcio-1.73.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:de18769aea47f18e782bf6819a37c1c528914bfd5683b8782b9da356506190c8", size = 6283902 }, + { url = "https://files.pythonhosted.org/packages/dc/64/18b77b89c5870d8ea91818feb0c3ffb5b31b48d1b0ee3e0f0d539730fea3/grpcio-1.73.1-cp312-cp312-win32.whl", hash = "sha256:24e06a5319e33041e322d32c62b1e728f18ab8c9dbc91729a3d9f9e3ed336642", size = 3668687 }, + { url = "https://files.pythonhosted.org/packages/3c/52/302448ca6e52f2a77166b2e2ed75f5d08feca4f2145faf75cb768cccb25b/grpcio-1.73.1-cp312-cp312-win_amd64.whl", hash = "sha256:303c8135d8ab176f8038c14cc10d698ae1db9c480f2b2823f7a987aa2a4c5646", size = 4334887 }, ] [[package]] name = "grpcio-status" -version = "1.71.0" +version = "1.73.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "googleapis-common-protos" }, { name = "grpcio" }, { name = "protobuf" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d7/53/a911467bece076020456401f55a27415d2d70d3bc2c37af06b44ea41fc5c/grpcio_status-1.71.0.tar.gz", hash = "sha256:11405fed67b68f406b3f3c7c5ae5104a79d2d309666d10d61b152e91d28fb968", size = 13669 } +sdist = { url = "https://files.pythonhosted.org/packages/f6/59/9350a13804f2e407d76b3962c548e023639fc1545056e342c6bad0d4fd30/grpcio_status-1.73.1.tar.gz", hash = "sha256:928f49ccf9688db5f20cd9e45c4578a1d01ccca29aeaabf066f2ac76aa886668", size = 13664 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ad/d6/31fbc43ff097d8c4c9fc3df741431b8018f67bf8dfbe6553a555f6e5f675/grpcio_status-1.71.0-py3-none-any.whl", hash = "sha256:843934ef8c09e3e858952887467f8256aac3910c55f077a359a65b2b3cde3e68", size = 14424 }, + { url = "https://files.pythonhosted.org/packages/2e/50/ee32e6073e2c3a4457be168e2bbf84d02ad9d2c18c4a578a641480c293d4/grpcio_status-1.73.1-py3-none-any.whl", hash = "sha256:538595c32a6c819c32b46a621a51e9ae4ffcd7e7e1bce35f728ef3447e9809b6", size = 14422 }, ] [[package]] @@ -1301,17 +1004,17 @@ wheels = [ [[package]] name = "hf-xet" -version = "1.1.4" +version = "1.1.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8d/11/b480bb7515db97d5b2b703927a59bbdd3f87e68d47dff5591aada467b4a9/hf_xet-1.1.4.tar.gz", hash = "sha256:875158df90cb13547752532ed73cad9dfaad3b29e203143838f67178418d08a4", size = 492082 } +sdist = { url = "https://files.pythonhosted.org/packages/ed/d4/7685999e85945ed0d7f0762b686ae7015035390de1161dcea9d5276c134c/hf_xet-1.1.5.tar.gz", hash = "sha256:69ebbcfd9ec44fdc2af73441619eeb06b94ee34511bbcf57cd423820090f5694", size = 495969 } wheels = [ - { url = "https://files.pythonhosted.org/packages/c4/62/3b41a7439930996530c64955874445012fd9044c82c60b34c5891c34fec6/hf_xet-1.1.4-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6591ab9f61ea82d261107ed90237e2ece972f6a7577d96f5f071208bbf255d1c", size = 2643151 }, - { url = "https://files.pythonhosted.org/packages/9b/9f/1744fb1d79e0ac147578b193ce29208ebb9f4636e8cdf505638f6f0a6874/hf_xet-1.1.4-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:071b0b4d4698990f746edd666c7cc42555833d22035d88db0df936677fb57d29", size = 2510687 }, - { url = "https://files.pythonhosted.org/packages/d1/a8/49a81d4f81b0d21cc758b6fca3880a85ca0d209e8425c8b3a6ef694881ca/hf_xet-1.1.4-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5b610831e92e41182d4c028653978b844d332d492cdcba1b920d3aca4a0207e", size = 3057631 }, - { url = "https://files.pythonhosted.org/packages/bf/8b/65fa08273789dafbc38d0f0bdd20df56b63ebc6566981bbaa255d9d84a33/hf_xet-1.1.4-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f6578bcd71393abfd60395279cc160ca808b61f5f9d535b922fcdcd3f77a708d", size = 2949250 }, - { url = "https://files.pythonhosted.org/packages/8b/4b/224340bb1d5c63b6e03e04095b4e42230848454bf4293c45cd7bdaa0c208/hf_xet-1.1.4-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fb2bbfa2aae0e4f0baca988e7ba8d8c1a39a25adf5317461eb7069ad00505b3e", size = 3124670 }, - { url = "https://files.pythonhosted.org/packages/4a/b7/4be010014de6585401c32a04c46b09a4a842d66bd16ed549a401e973b74b/hf_xet-1.1.4-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:73346ba3e2e15ea8909a26b0862b458f15b003e6277935e3fba5bf273508d698", size = 3234131 }, - { url = "https://files.pythonhosted.org/packages/c2/2d/cf148d532f741fbf93f380ff038a33c1309d1e24ea629dc39d11dca08c92/hf_xet-1.1.4-cp37-abi3-win_amd64.whl", hash = "sha256:52e8f8bc2029d8b911493f43cea131ac3fa1f0dc6a13c50b593c4516f02c6fc3", size = 2695589 }, + { url = "https://files.pythonhosted.org/packages/00/89/a1119eebe2836cb25758e7661d6410d3eae982e2b5e974bcc4d250be9012/hf_xet-1.1.5-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f52c2fa3635b8c37c7764d8796dfa72706cc4eded19d638331161e82b0792e23", size = 2687929 }, + { url = "https://files.pythonhosted.org/packages/de/5f/2c78e28f309396e71ec8e4e9304a6483dcbc36172b5cea8f291994163425/hf_xet-1.1.5-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:9fa6e3ee5d61912c4a113e0708eaaef987047616465ac7aa30f7121a48fc1af8", size = 2556338 }, + { url = "https://files.pythonhosted.org/packages/6d/2f/6cad7b5fe86b7652579346cb7f85156c11761df26435651cbba89376cd2c/hf_xet-1.1.5-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc874b5c843e642f45fd85cda1ce599e123308ad2901ead23d3510a47ff506d1", size = 3102894 }, + { url = "https://files.pythonhosted.org/packages/d0/54/0fcf2b619720a26fbb6cc941e89f2472a522cd963a776c089b189559447f/hf_xet-1.1.5-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dbba1660e5d810bd0ea77c511a99e9242d920790d0e63c0e4673ed36c4022d18", size = 3002134 }, + { url = "https://files.pythonhosted.org/packages/f3/92/1d351ac6cef7c4ba8c85744d37ffbfac2d53d0a6c04d2cabeba614640a78/hf_xet-1.1.5-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ab34c4c3104133c495785d5d8bba3b1efc99de52c02e759cf711a91fd39d3a14", size = 3171009 }, + { url = "https://files.pythonhosted.org/packages/c9/65/4b2ddb0e3e983f2508528eb4501288ae2f84963586fbdfae596836d5e57a/hf_xet-1.1.5-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:83088ecea236d5113de478acb2339f92c95b4fb0462acaa30621fac02f5a534a", size = 3279245 }, + { url = "https://files.pythonhosted.org/packages/f0/55/ef77a85ee443ae05a9e9cba1c9f0dd9241eb42da2aeba1dc50f51154c81a/hf_xet-1.1.5-cp37-abi3-win_amd64.whl", hash = "sha256:73e167d9807d166596b4b2f0b585c6d5bd84a26dea32843665a8b58f6edba245", size = 2738931 }, ] [[package]] @@ -1327,32 +1030,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 }, ] -[[package]] -name = "httplib2" -version = "0.22.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyparsing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3d/ad/2371116b22d616c194aa25ec410c9c6c37f23599dcd590502b74db197584/httplib2-0.22.0.tar.gz", hash = "sha256:d7a10bc5ef5ab08322488bde8c726eeee5c8618723fdb399597ec58f3d82df81", size = 351116 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a8/6c/d2fbdaaa5959339d53ba38e94c123e4e84b8fbc4b84beb0e70d7c1608486/httplib2-0.22.0-py3-none-any.whl", hash = "sha256:14ae0a53c1ba8f3d37e9e27cf37eabb0fb9980f435ba405d546948b009dd64dc", size = 96854 }, -] - [[package]] name = "httpx" -version = "0.27.2" +version = "0.28.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, { name = "certifi" }, { name = "httpcore" }, { name = "idna" }, - { name = "sniffio" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/78/82/08f8c936781f67d9e6b9eeb8a0c8b4e406136ea4c3d1f89a5db71d42e0e6/httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2", size = 144189 } +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } wheels = [ - { url = "https://files.pythonhosted.org/packages/56/95/9377bcb415797e44274b51d46e3249eba641711cf3348050f76ee7b15ffc/httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0", size = 76395 }, + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, ] [package.optional-dependencies] @@ -1362,16 +1052,16 @@ socks = [ [[package]] name = "httpx-sse" -version = "0.4.0" +version = "0.4.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4c/60/8f4281fa9bbf3c8034fd54c0e7412e66edbab6bc74c4996bd616f8d0406e/httpx-sse-0.4.0.tar.gz", hash = "sha256:1e81a3a3070ce322add1d3529ed42eb5f70817f45ed6ec915ab753f961139721", size = 12624 } +sdist = { url = "https://files.pythonhosted.org/packages/6e/fa/66bd985dd0b7c109a3bcb89272ee0bfb7e2b4d06309ad7b38ff866734b2a/httpx_sse-0.4.1.tar.gz", hash = "sha256:8f44d34414bc7b21bf3602713005c5df4917884f76072479b21f68befa4ea26e", size = 12998 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/9b/a181f281f65d776426002f330c31849b86b31fc9d848db62e16f03ff739f/httpx_sse-0.4.0-py3-none-any.whl", hash = "sha256:f329af6eae57eaa2bdfd962b42524764af68075ea87370a2de920af5341e318f", size = 7819 }, + { url = "https://files.pythonhosted.org/packages/25/0a/6269e3473b09aed2dab8aa1a600c70f31f00ae1349bee30658f7e358a159/httpx_sse-0.4.1-py3-none-any.whl", hash = "sha256:cba42174344c3a5b06f255ce65b350880f962d99ead85e776f23c6618a377a37", size = 8054 }, ] [[package]] name = "huggingface-hub" -version = "0.33.0" +version = "0.33.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "filelock" }, @@ -1383,9 +1073,9 @@ dependencies = [ { name = "tqdm" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/91/8a/1362d565fefabaa4185cf3ae842a98dbc5b35146f5694f7080f043a6952f/huggingface_hub-0.33.0.tar.gz", hash = "sha256:aa31f70d29439d00ff7a33837c03f1f9dd83971ce4e29ad664d63ffb17d3bb97", size = 426179 } +sdist = { url = "https://files.pythonhosted.org/packages/4b/9e/9366b7349fc125dd68b9d384a0fea84d67b7497753fe92c71b67e13f47c4/huggingface_hub-0.33.4.tar.gz", hash = "sha256:6af13478deae120e765bfd92adad0ae1aec1ad8c439b46f23058ad5956cbca0a", size = 426674 } wheels = [ - { url = "https://files.pythonhosted.org/packages/33/fb/53587a89fbc00799e4179796f51b3ad713c5de6bb680b2becb6d37c94649/huggingface_hub-0.33.0-py3-none-any.whl", hash = "sha256:e8668875b40c68f9929150d99727d39e5ebb8a05a98e4191b908dc7ded9074b3", size = 514799 }, + { url = "https://files.pythonhosted.org/packages/46/7b/98daa50a2db034cab6cd23a3de04fa2358cb691593d28e9130203eb7a805/huggingface_hub-0.33.4-py3-none-any.whl", hash = "sha256:09f9f4e7ca62547c70f8b82767eefadd2667f4e116acba2e3e62a5a81815a7bb", size = 515339 }, ] [[package]] @@ -1442,36 +1132,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2c/c6/fa760e12a2483469e2bf5058c5faff664acf66cadb4df2ad6205b016a73d/imageio_ffmpeg-0.6.0-py3-none-win_amd64.whl", hash = "sha256:02fa47c83703c37df6bfe4896aab339013f62bf02c5ebf2dce6da56af04ffc0a", size = 31246824 }, ] -[[package]] -name = "imagesize" -version = "1.4.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769 }, -] - -[[package]] -name = "importlib-metadata" -version = "8.7.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "zipp" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656 }, -] - -[[package]] -name = "iniconfig" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 }, -] - [[package]] name = "ipykernel" version = "6.29.5" @@ -1498,10 +1158,10 @@ wheels = [ [[package]] name = "ipython" -version = "9.3.0" +version = "9.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, { name = "decorator" }, { name = "ipython-pygments-lexers" }, { name = "jedi" }, @@ -1513,9 +1173,9 @@ dependencies = [ { name = "traitlets" }, { name = "typing-extensions", marker = "python_full_version < '3.12'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/dc/09/4c7e06b96fbd203e06567b60fb41b06db606b6a82db6db7b2c85bb72a15c/ipython-9.3.0.tar.gz", hash = "sha256:79eb896f9f23f50ad16c3bc205f686f6e030ad246cc309c6279a242b14afe9d8", size = 4426460 } +sdist = { url = "https://files.pythonhosted.org/packages/54/80/406f9e3bde1c1fd9bf5a0be9d090f8ae623e401b7670d8f6fdf2ab679891/ipython-9.4.0.tar.gz", hash = "sha256:c033c6d4e7914c3d9768aabe76bbe87ba1dc66a92a05db6bfa1125d81f2ee270", size = 4385338 } wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/99/9ed3d52d00f1846679e3aa12e2326ac7044b5e7f90dc822b60115fa533ca/ipython-9.3.0-py3-none-any.whl", hash = "sha256:1a0b6dd9221a1f5dddf725b57ac0cb6fddc7b5f470576231ae9162b9b3455a04", size = 605320 }, + { url = "https://files.pythonhosted.org/packages/63/f8/0031ee2b906a15a33d6bfc12dd09c3dfa966b3cb5b284ecfb7549e6ac3c4/ipython-9.4.0-py3-none-any.whl", hash = "sha256:25850f025a446d9b359e8d296ba175a36aedd32e83ca9b5060430fe16801f066", size = 611021 }, ] [[package]] @@ -1602,18 +1262,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9b/52/7ec47455e26f2d6e5f2ea4951a0652c06e5b995c291f723973ae9e724a65/jiter-0.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:a7c7d785ae9dda68c2678532a5a1581347e9c15362ae9f6e68f3fdbfb64f2e49", size = 206176 }, ] -[[package]] -name = "jsonlines" -version = "3.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2a/c8/efdb87403dae07cf20faf75449eae41898b71d6a8d4ebaf9c80d5be215f5/jsonlines-3.1.0.tar.gz", hash = "sha256:2579cb488d96f815b0eb81629e3e6b0332da0962a18fa3532958f7ba14a5c37f", size = 8510 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/68/32/290ca20eb3a2b97ffa6ba1791fcafacb3cd2f41f539c96eb54cfc3cfcf47/jsonlines-3.1.0-py3-none-any.whl", hash = "sha256:632f5e38f93dfcb1ac8c4e09780b92af3a55f38f26e7c47ae85109d420b6ad39", size = 8592 }, -] - [[package]] name = "jsonpatch" version = "1.33" @@ -1635,15 +1283,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595 }, ] -[[package]] -name = "jsonref" -version = "1.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425 }, -] - [[package]] name = "jsonschema" version = "4.24.0" @@ -1693,7 +1332,7 @@ version = "5.8.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "platformdirs" }, - { name = "pywin32", marker = "(platform_machine != 'aarch64' and platform_python_implementation != 'PyPy' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_python_implementation != 'PyPy' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923 } @@ -1701,15 +1340,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880 }, ] -[[package]] -name = "jupyterlab-pygments" -version = "0.3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, -] - [[package]] name = "jupyterlab-widgets" version = "3.0.15" @@ -1721,7 +1351,7 @@ wheels = [ [[package]] name = "langchain" -version = "0.3.25" +version = "0.3.26" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "langchain-core" }, @@ -1732,28 +1362,28 @@ dependencies = [ { name = "requests" }, { name = "sqlalchemy" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/f9/a256609096a9fc7a1b3a6300a97000091efabdf21555a97988f93d4d9258/langchain-0.3.25.tar.gz", hash = "sha256:a1d72aa39546a23db08492d7228464af35c9ee83379945535ceef877340d2a3a", size = 10225045 } +sdist = { url = "https://files.pythonhosted.org/packages/7f/13/a9931800ee42bbe0f8850dd540de14e80dda4945e7ee36e20b5d5964286e/langchain-0.3.26.tar.gz", hash = "sha256:8ff034ee0556d3e45eff1f1e96d0d745ced57858414dba7171c8ebdbeb5580c9", size = 10226808 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/5c/5c0be747261e1f8129b875fa3bfea736bc5fe17652f9d5e15ca118571b6f/langchain-0.3.25-py3-none-any.whl", hash = "sha256:931f7d2d1eaf182f9f41c5e3272859cfe7f94fc1f7cef6b3e5a46024b4884c21", size = 1011008 }, + { url = "https://files.pythonhosted.org/packages/f1/f2/c09a2e383283e3af1db669ab037ac05a45814f4b9c472c48dc24c0cef039/langchain-0.3.26-py3-none-any.whl", hash = "sha256:361bb2e61371024a8c473da9f9c55f4ee50f269c5ab43afdb2b1309cb7ac36cf", size = 1012336 }, ] [[package]] name = "langchain-anthropic" -version = "0.3.15" +version = "0.3.17" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anthropic" }, { name = "langchain-core" }, { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/47/c5/c5cd0164e342812787c157a385e8a9529510a514a5fe6acb487e990e82b0/langchain_anthropic-0.3.15.tar.gz", hash = "sha256:e62de2b0175c1fcca49fc4cc1f8742a4ab2385f0b94b7df4533fd06d577efd36", size = 54218 } +sdist = { url = "https://files.pythonhosted.org/packages/e6/f7/991cefafa798c4f868637ea5733a62d15932a15d031898fcb3462253d60f/langchain_anthropic-0.3.17.tar.gz", hash = "sha256:f2c2a0382ed7992204d790ff8538448f5243f4dbb1e798256ef790c9a69033e4", size = 55831 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/c0/9a1d58ab8718505bf25b7ad375a2a104886dfe64519d8b96442bb295637e/langchain_anthropic-0.3.15-py3-none-any.whl", hash = "sha256:894d670bc44e68e0b1f2f09e7e7f977a8f07085a596f114c79aefbb789f6d88d", size = 28054 }, + { url = "https://files.pythonhosted.org/packages/6c/8e/055c65bdb3c240297676d57d705bee6d472f47ace6e28b009f0faf5c6970/langchain_anthropic-0.3.17-py3-none-any.whl", hash = "sha256:6df784615b93aab0336fbd6a50ca2bd16a704ef01c9488c36a4fa7aad2faf2d6", size = 29239 }, ] [[package]] name = "langchain-community" -version = "0.3.25" +version = "0.3.27" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp" }, @@ -1769,14 +1399,14 @@ dependencies = [ { name = "sqlalchemy" }, { name = "tenacity" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c0/9b/332e69933ce7d96153fe5468d5428052ae20b143fa0dba0c78eea8859f94/langchain_community-0.3.25.tar.gz", hash = "sha256:a536888a48b36184dee20df86d266827a01916397fb398af2088ab7c3dfee684", size = 33235586 } +sdist = { url = "https://files.pythonhosted.org/packages/5c/76/200494f6de488217a196c4369e665d26b94c8c3642d46e2fd62f9daf0a3a/langchain_community-0.3.27.tar.gz", hash = "sha256:e1037c3b9da0c6d10bf06e838b034eb741e016515c79ef8f3f16e53ead33d882", size = 33237737 } wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/e1/975bcd11e86de74c10023d291879810d4eaffcfbb5d4c0d8fb6fb41b8247/langchain_community-0.3.25-py3-none-any.whl", hash = "sha256:0d7f673d463019ab1aca4e50e750048214a7772efd2c8e1d59256739b8318f97", size = 2529170 }, + { url = "https://files.pythonhosted.org/packages/c8/bc/f8c7dae8321d37ed39ac9d7896617c4203248240a4835b136e3724b3bb62/langchain_community-0.3.27-py3-none-any.whl", hash = "sha256:581f97b795f9633da738ea95da9cb78f8879b538090c9b7a68c0aed49c828f0d", size = 2530442 }, ] [[package]] name = "langchain-core" -version = "0.3.65" +version = "0.3.68" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jsonpatch" }, @@ -1787,9 +1417,9 @@ dependencies = [ { name = "tenacity" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/04/8a/d08c83195d1ef26c42728412ab92ab08211893906b283abce65775e21327/langchain_core-0.3.65.tar.gz", hash = "sha256:54b5e0c8d9bb405415c3211da508ef9cfe0acbe5b490d1b4a15664408ee82d9b", size = 558557 } +sdist = { url = "https://files.pythonhosted.org/packages/23/20/f5b18a17bfbe3416177e702ab2fd230b7d168abb17be31fb48f43f0bb772/langchain_core-0.3.68.tar.gz", hash = "sha256:312e1932ac9aa2eaf111b70fdc171776fa571d1a86c1f873dcac88a094b19c6f", size = 563041 } wheels = [ - { url = "https://files.pythonhosted.org/packages/54/f0/31db18b7b8213266aed926ce89b5bdd84ccde7ee2edf4cab14e3dd2bfcf1/langchain_core-0.3.65-py3-none-any.whl", hash = "sha256:80e8faf6e9f331f8ef728f3fe793549f1d3fb244fcf9e1bdcecab6a6f4669394", size = 438052 }, + { url = "https://files.pythonhosted.org/packages/f9/da/c89be0a272993bfcb762b2a356b9f55de507784c2755ad63caec25d183bf/langchain_core-0.3.68-py3-none-any.whl", hash = "sha256:5e5c1fbef419590537c91b8c2d86af896fbcbaf0d5ed7fdcdd77f7d8f3467ba0", size = 441405 }, ] [[package]] @@ -1807,52 +1437,56 @@ wheels = [ [[package]] name = "langchain-google-genai" -version = "2.0.10" +version = "2.1.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "filetype" }, - { name = "google-generativeai" }, + { name = "google-ai-generativelanguage" }, { name = "langchain-core" }, { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/788360ec44b4b280d754db92f9e204ddd96bd6730fad8a9ff9b1319c7e71/langchain_google_genai-2.0.10.tar.gz", hash = "sha256:b51067b468853856f275bb7b1a85dbaf4467b59fe67e35fcd614fc0d744c810e", size = 37699 } +sdist = { url = "https://files.pythonhosted.org/packages/d2/03/5ff9f00f942a3ea695a8e250b0ae681c50c8eacee21f716d7668a8bd0a82/langchain_google_genai-2.1.7.tar.gz", hash = "sha256:a0e77f06175843e527d7bcde195cc0332bf538416038e7de8e5a4bd256801181", size = 43917 } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/ce/d2a9c47cdb0684160f5e9717534fc1adc22b326ae70348caa5552dd66953/langchain_google_genai-2.0.10-py3-none-any.whl", hash = "sha256:964a7542fd11fdec7592052b4eaef383227f7c4fa4d754a455e4bf0634f4ad28", size = 41980 }, + { url = "https://files.pythonhosted.org/packages/76/54/159d13ef38dea4a16ecfb51ccc213912b1ac9fdbc2f84f556b7bca5e495e/langchain_google_genai-2.1.7-py3-none-any.whl", hash = "sha256:df90736536d71d5a2eb3117ed9df9c86e10bcf03b51d883ee5d2a727771f4bc3", size = 47433 }, ] [[package]] name = "langchain-google-vertexai" -version = "2.0.10" +version = "2.0.27" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "bottleneck" }, { name = "google-cloud-aiplatform" }, { name = "google-cloud-storage" }, { name = "httpx" }, { name = "httpx-sse" }, { name = "langchain-core" }, + { name = "numexpr" }, + { name = "pyarrow" }, { name = "pydantic" }, + { name = "validators" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1e/69/41c5a2dd769e782972b82d8279dfdd0ab2bc647248cafaaa2f2f2365a049/langchain_google_vertexai-2.0.10.tar.gz", hash = "sha256:02e3dca590d1f20e63a6e4aa48693183c551a1e98a0476cdbbdba1e5f80b30f9", size = 77205 } +sdist = { url = "https://files.pythonhosted.org/packages/cf/6f/98f856718d8565f8caaa4b314c139b2af17e42d92ea43db09d8a84b8f6f4/langchain_google_vertexai-2.0.27.tar.gz", hash = "sha256:7e8f7e8ef6d321b64d37fc1c9324a13a34b26882ec02f92c0a86329f18895fd9", size = 85232 } wheels = [ - { url = "https://files.pythonhosted.org/packages/28/3c/2f70d73d2cc9a40806a2a96cb44f7ba4999606add4885f28584a09959aa2/langchain_google_vertexai-2.0.10-py3-none-any.whl", hash = "sha256:192a5ac1c9165652a9b7bd936740be5d9efbecc6589f9865530d62c9054b3a1c", size = 92234 }, + { url = "https://files.pythonhosted.org/packages/07/34/0235af453fc44d6474634da50302cd0a0a38c545a71e4c2a3458b2619746/langchain_google_vertexai-2.0.27-py3-none-any.whl", hash = "sha256:4637d64aea1803ecefbcf411587fce358afac52ff8e88cfe89615fcd92c3701d", size = 101007 }, ] [[package]] name = "langchain-groq" -version = "0.3.2" +version = "0.3.6" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "groq" }, { name = "langchain-core" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e0/4c/973faadcc54fc74352c6758208f48b08dd072025ab33beea52e6c31d4cd1/langchain_groq-0.3.2.tar.gz", hash = "sha256:033f459d4c0515e22a6e64f5a402e366933a6c827fd5915547419cb62fd7b34a", size = 22074 } +sdist = { url = "https://files.pythonhosted.org/packages/c2/d3/abeb19b686961dd5a99a43f5f92554135e444e0f291fca19b14e8d0d9f57/langchain_groq-0.3.6.tar.gz", hash = "sha256:ca6f94e250357d1e77b348e002d7da4fcf674fde4c9df1827431b430e45d88de", size = 24372 } wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/58/0d5a19168119c1bd7758ab28d9e6b5c12ba1091bb283f4dc13ca5df7651b/langchain_groq-0.3.2-py3-none-any.whl", hash = "sha256:bc111dea17a3510498c4697c42bf97e629bcf8f00b97fa25e51ea7947fc0b540", size = 15253 }, + { url = "https://files.pythonhosted.org/packages/c2/7d/7b5967f6bbe0248cebfee14a6e499873d81bbb761df6531d43ad166faf11/langchain_groq-0.3.6-py3-none-any.whl", hash = "sha256:51aff1ecc5472e031b06f41cd2219c238b7c862935ef90e15283e5d04d9e7207", size = 16351 }, ] [[package]] name = "langchain-mistralai" -version = "0.2.10" +version = "0.2.11" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx" }, @@ -1861,36 +1495,36 @@ dependencies = [ { name = "pydantic" }, { name = "tokenizers" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/dc/04/cd75dd40f55925b5fdcc96b0f9a22cc05e3711c2d270cf8b7948d5f389f0/langchain_mistralai-0.2.10.tar.gz", hash = "sha256:698620c7dee8ae85bf1ca1ed5b544285c0764c453efead9a4ae34ab884704ce1", size = 21560 } +sdist = { url = "https://files.pythonhosted.org/packages/6d/f5/7afd7dcd252e5abaaf3a13849733a32aaf0b5f2290dc62bd2c72afdc33e4/langchain_mistralai-0.2.11.tar.gz", hash = "sha256:0816bb9972c9e407d9eca567ad16095ec4f0f5bb9094890692ceb149aa72c71e", size = 21718 } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/d2/d1238951c6f522b7442558cb860dbde9658b8c5d766c6d5d7f7fde0b7f76/langchain_mistralai-0.2.10-py3-none-any.whl", hash = "sha256:fc3bc813eab034335236a3b01ba189cd00bcf2b7e6ac57628d0409438bd13425", size = 16526 }, + { url = "https://files.pythonhosted.org/packages/48/35/cf2e31b5af5b6798437bb7c92b13d0ed7c4bdde87034227b49be907fe272/langchain_mistralai-0.2.11-py3-none-any.whl", hash = "sha256:6940b551f8e63ca9163e8f5a156aab6814238f9b19302405b6af9d8703e7f762", size = 16560 }, ] [[package]] name = "langchain-ollama" -version = "0.3.3" +version = "0.3.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "langchain-core" }, { name = "ollama" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/59/9f/6683f69f14b0cde3556c6b7752fb290bfce743981dc1312efa924619365f/langchain_ollama-0.3.3.tar.gz", hash = "sha256:7d6ed75bfb706751b83173fe886b72ae25bb0b1bd7f3eb2622821c4149f7807b", size = 21913 } +sdist = { url = "https://files.pythonhosted.org/packages/b4/ff/b75aa20bfd17679464ce88e1a2b8103328843bcd669eecbce5bc4d671552/langchain_ollama-0.3.4.tar.gz", hash = "sha256:68d7e0a36eb0ab8130c774283c040152b853e25a6a3aab4bca654c02499f1010", size = 28342 } wheels = [ - { url = "https://files.pythonhosted.org/packages/84/6f/ab7a470522e27b95ed008eb9ef81b1ab55321f3f3aff21ca0109aae53cdf/langchain_ollama-0.3.3-py3-none-any.whl", hash = "sha256:f1c745a4b59d36bb51995c23c6b0fbc20f71956715659425ab88639a14b213cd", size = 21156 }, + { url = "https://files.pythonhosted.org/packages/db/88/bab55e2ae39447c7fbd54f69b9a11330ef615e400f0dda01f12d51812ab2/langchain_ollama-0.3.4-py3-none-any.whl", hash = "sha256:62929a61cd4204d26ad15f591400c8d8d8042a390e46ea02db117e277ffcb45a", size = 23773 }, ] [[package]] name = "langchain-openai" -version = "0.3.24" +version = "0.3.27" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "langchain-core" }, { name = "openai" }, { name = "tiktoken" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/da/e1/7be9384c5cb6fd6d0466ac6e781e44c3d80081c624faa7a9d2f8bf3a59ba/langchain_openai-0.3.24.tar.gz", hash = "sha256:cec1ab4ce7a8680af1eb11427b4384d2ceb46e9b20ff3f7beb0b0d83cab61a97", size = 687773 } +sdist = { url = "https://files.pythonhosted.org/packages/6f/7b/e65261a08a03dd43f0ef8a539930b56548ac8136e71258c220d3589d1d07/langchain_openai-0.3.27.tar.gz", hash = "sha256:5d5a55adbff739274dfc3a4102925771736f893758f63679b64ae62fed79ca30", size = 753326 } wheels = [ - { url = "https://files.pythonhosted.org/packages/fc/9b/b8f86d78dbc651decd684ab938a1340e1ad3ba1dbcef805e12db65dee0ba/langchain_openai-0.3.24-py3-none-any.whl", hash = "sha256:3db7bb2964f86636276a8f4bbed4514daf13865b80896e547ff7ea13ce98e593", size = 68950 }, + { url = "https://files.pythonhosted.org/packages/aa/31/1f0baf6490b082bf4d06f355c5e9c28728931dbf321f3ca03137617a692e/langchain_openai-0.3.27-py3-none-any.whl", hash = "sha256:efe636c3523978c44adc41cf55c8b3766c05c77547982465884d1258afe705df", size = 70368 }, ] [[package]] @@ -1916,7 +1550,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/0e/72/a3add0e4eec4eb9e2 [[package]] name = "langgraph" -version = "0.4.8" +version = "0.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "langchain-core" }, @@ -1926,9 +1560,9 @@ dependencies = [ { name = "pydantic" }, { name = "xxhash" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9b/53/03380b675fef3d00d2d270e530d1a8bfe4e6f27117016a478670c9c74469/langgraph-0.4.8.tar.gz", hash = "sha256:48445ac8a351b7bdc6dee94e2e6a597f8582e0516ebd9dea0fd0164ae01b915e", size = 453277 } +sdist = { url = "https://files.pythonhosted.org/packages/c0/18/1e255fc8c36ff5056d797d83c9ca9fd926683ace294a9ba38c4b40599237/langgraph-0.5.2.tar.gz", hash = "sha256:393b767e9d6a129636a9df36edc492499336c71e4ee268e64b9d1299d30e636c", size = 442564 } wheels = [ - { url = "https://files.pythonhosted.org/packages/17/8a/fe05ec63ee4c3889a8b89679a6bdd1be6087962818996f3b361da23a5529/langgraph-0.4.8-py3-none-any.whl", hash = "sha256:273b02782669a474ba55ef4296607ac3bac9e93639d37edc0d32d8cf1a41a45b", size = 152444 }, + { url = "https://files.pythonhosted.org/packages/3b/44/6e6c41a3cc00d533dc91cc5f086862b1fccf34aa0ec9605a2cbd116c6ba0/langgraph-0.5.2-py3-none-any.whl", hash = "sha256:db6b8053bf99887957fe45ec27918f8819c4bba269afde88b538e00e9301a581", size = 143735 }, ] [[package]] @@ -1960,33 +1594,33 @@ wheels = [ [[package]] name = "langgraph-prebuilt" -version = "0.2.2" +version = "0.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "langchain-core" }, { name = "langgraph-checkpoint" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/88/f5/15b26cda94ebb89400048d478a3b1927005d85e273a557d8683f4cda775c/langgraph_prebuilt-0.2.2.tar.gz", hash = "sha256:0a5d1f651f97c848cd1c3dd0ef017614f47ee74effb7375b59ac639e41b253f9", size = 112785 } +sdist = { url = "https://files.pythonhosted.org/packages/bb/11/98134c47832fbde0caf0e06f1a104577da9215c358d7854093c1d835b272/langgraph_prebuilt-0.5.2.tar.gz", hash = "sha256:2c900a5be0d6a93ea2521e0d931697cad2b646f1fcda7aa5c39d8d7539772465", size = 117808 } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/46/c98fec1f8620cbffbabda346a2c68155eec3720c6c3393ab3b9529618810/langgraph_prebuilt-0.2.2-py3-none-any.whl", hash = "sha256:72de5ef1d969a8f02ad7adc7cc1915bb9b4467912d57ba60da34b5a70fdad1f6", size = 23748 }, + { url = "https://files.pythonhosted.org/packages/c3/64/6bc45ab9e0e1112698ebff579fe21f5606ea65cd08266995a357e312a4d2/langgraph_prebuilt-0.5.2-py3-none-any.whl", hash = "sha256:1f4cd55deca49dffc3e5127eec12fcd244fc381321002f728afa88642d5ec59d", size = 23776 }, ] [[package]] name = "langgraph-sdk" -version = "0.1.70" +version = "0.1.72" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx" }, { name = "orjson" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c1/dd/c074adf91d2fe67f00dc3be4348119f40a9d0ead9e55c958f81492c522c0/langgraph_sdk-0.1.70.tar.gz", hash = "sha256:cc65ec33bcdf8c7008d43da2d2b0bc1dd09f98d21a7f636828d9379535069cf9", size = 71530 } +sdist = { url = "https://files.pythonhosted.org/packages/c0/a6/cf13ace9bc7f0e8b13852ced0b37ece97f3140e232821c28bc852f8c1ea2/langgraph_sdk-0.1.72.tar.gz", hash = "sha256:396d8195881830700e2d54a0a9ee273e8b1173428e667502ef9c182a3cec7ab7", size = 71600 } wheels = [ - { url = "https://files.pythonhosted.org/packages/8c/77/b0930ca5d54ef91e2bdb37e0f7dbeda1923e1e0b5b71ab3af35c103c2e39/langgraph_sdk-0.1.70-py3-none-any.whl", hash = "sha256:47f2b04a964f40a610c1636b387ea52f961ce7a233afc21d3103e5faac8ca1e5", size = 49986 }, + { url = "https://files.pythonhosted.org/packages/4b/4b/d56b51da08d168c2315cd092faa47bc83388b116756dbd6995026ec9ba3f/langgraph_sdk-0.1.72-py3-none-any.whl", hash = "sha256:925d3fcc7a26361db04f9c4beb3ec05bc36361b2a836d181ff2ab145071ec3ce", size = 50129 }, ] [[package]] name = "langsmith" -version = "0.3.45" +version = "0.4.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx" }, @@ -1997,99 +1631,18 @@ dependencies = [ { name = "requests-toolbelt" }, { name = "zstandard" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/be/86/b941012013260f95af2e90a3d9415af4a76a003a28412033fc4b09f35731/langsmith-0.3.45.tar.gz", hash = "sha256:1df3c6820c73ed210b2c7bc5cdb7bfa19ddc9126cd03fdf0da54e2e171e6094d", size = 348201 } +sdist = { url = "https://files.pythonhosted.org/packages/5c/92/7885823f3d13222f57773921f0da19b37d628c64607491233dc853a0f6ea/langsmith-0.4.5.tar.gz", hash = "sha256:49444bd8ccd4e46402f1b9ff1d686fa8e3a31b175e7085e72175ab8ec6164a34", size = 352235 } wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/f4/c206c0888f8a506404cb4f16ad89593bdc2f70cf00de26a1a0a7a76ad7a3/langsmith-0.3.45-py3-none-any.whl", hash = "sha256:5b55f0518601fa65f3bb6b1a3100379a96aa7b3ed5e9380581615ba9c65ed8ed", size = 363002 }, + { url = "https://files.pythonhosted.org/packages/c8/10/ad3107b666c3203b7938d10ea6b8746b9735c399cf737a51386d58e41d34/langsmith-0.4.5-py3-none-any.whl", hash = "sha256:4167717a2cccc4dff5809dbddc439628e836f6fd13d4fdb31ea013bc8d5cfaf5", size = 367795 }, ] -[[package]] -name = "latex2mathml" -version = "3.78.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/69/33/ad2c3929494ad160f5130ea132ca298627a6c81c70be6bedd1bc806b5b01/latex2mathml-3.78.0.tar.gz", hash = "sha256:712193aa4c6ade1a8e0145dac7bc1f9aafbd54f93046a2356a7e1c05fa0f8b31", size = 73737 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/fd/aba08bb9e527168efad57985d7db9a853eb2384b1efa5ca5f3a3794c9cef/latex2mathml-3.78.0-py3-none-any.whl", hash = "sha256:1aeca3dc027b3006ad7b301b7f4a15ffbb4c1451e3dc8c3389e97b37b497e1d6", size = 73673 }, -] - -[[package]] -name = "lazy-loader" -version = "0.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "packaging" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6f/6b/c875b30a1ba490860c93da4cabf479e03f584eba06fe5963f6f6644653d8/lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1", size = 15431 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097 }, -] - -[[package]] -name = "levenshtein" -version = "0.26.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "rapidfuzz" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/97/e6/79807d3b59a67dd78bb77072ca6a28d8db0935161fecf935e6c38c5f6825/levenshtein-0.26.1.tar.gz", hash = "sha256:0d19ba22330d50609b2349021ec3cf7d905c6fe21195a2d0d876a146e7ed2575", size = 374307 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/b4/86e447173ca8d936b7ef270d21952a0053e799040e73b843a4a5ac9a15a1/levenshtein-0.26.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:44c51f5d33b3cfb9db518b36f1288437a509edd82da94c4400f6a681758e0cb6", size = 177037 }, - { url = "https://files.pythonhosted.org/packages/27/b3/e15e14e5836dfc23ed014c21b307cbf77b3c6fd75e11d0675ce9a0d43b31/levenshtein-0.26.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:56b93203e725f9df660e2afe3d26ba07d71871b6d6e05b8b767e688e23dfb076", size = 157478 }, - { url = "https://files.pythonhosted.org/packages/32/f1/f4d0904c5074e4e9d33dcaf304144e02eae9eec9d61b63bf17b1108ce228/levenshtein-0.26.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:270d36c5da04a0d89990660aea8542227cbd8f5bc34e9fdfadd34916ff904520", size = 153873 }, - { url = "https://files.pythonhosted.org/packages/f9/0d/cd5abe809421ce0d4a2cae60fd2fdf62cb43890068515a8a0069e2b17894/levenshtein-0.26.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:480674c05077eeb0b0f748546d4fcbb386d7c737f9fff0010400da3e8b552942", size = 186850 }, - { url = "https://files.pythonhosted.org/packages/a8/69/03f4266ad83781f2602b1976a2e5a98785c148f9bfc77c343e5aa1840f64/levenshtein-0.26.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:13946e37323728695ba7a22f3345c2e907d23f4600bc700bf9b4352fb0c72a48", size = 187527 }, - { url = "https://files.pythonhosted.org/packages/36/fa/ec3be1162b1a757f80e713220470fe5b4db22e23f886f50ac59a48f0a84d/levenshtein-0.26.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ceb673f572d1d0dc9b1cd75792bb8bad2ae8eb78a7c6721e23a3867d318cb6f2", size = 162673 }, - { url = "https://files.pythonhosted.org/packages/9e/d6/dc8358b6a4174f413532aa27463dc4d167ac25742826f58916bb6e6417b1/levenshtein-0.26.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42d6fa242e3b310ce6bfd5af0c83e65ef10b608b885b3bb69863c01fb2fcff98", size = 250413 }, - { url = "https://files.pythonhosted.org/packages/57/5e/a87bf39686482a1df000fdc265fdd812f0cd316d5fb0a25f52654504a82b/levenshtein-0.26.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b8b68295808893a81e0a1dbc2274c30dd90880f14d23078e8eb4325ee615fc68", size = 1078713 }, - { url = "https://files.pythonhosted.org/packages/c5/04/30ab2f27c4ff7d6d98b3bb6bf8541521535ad2d05e50ac8fd00ab701c080/levenshtein-0.26.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b01061d377d1944eb67bc40bef5d4d2f762c6ab01598efd9297ce5d0047eb1b5", size = 1331174 }, - { url = "https://files.pythonhosted.org/packages/e4/68/9c7f60ccb097a86420d058dcc3f575e6b3d663b3a5cde3651443f7087e14/levenshtein-0.26.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9d12c8390f156745e533d01b30773b9753e41d8bbf8bf9dac4b97628cdf16314", size = 1207733 }, - { url = "https://files.pythonhosted.org/packages/64/21/222f54a1a654eca1c1cd015d32d972d70529eb218d469d516f13eac2149d/levenshtein-0.26.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:48825c9f967f922061329d1481b70e9fee937fc68322d6979bc623f69f75bc91", size = 1356116 }, - { url = "https://files.pythonhosted.org/packages/6f/65/681dced2fa798ea7882bff5682ab566689a4920006ed9aca4fd8d1edb2d2/levenshtein-0.26.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d8ec137170b95736842f99c0e7a9fd8f5641d0c1b63b08ce027198545d983e2b", size = 1135459 }, - { url = "https://files.pythonhosted.org/packages/a1/e8/1ff8a634c428ed908d20482f77491cca08fa16c96738ad82d9219da138a1/levenshtein-0.26.1-cp311-cp311-win32.whl", hash = "sha256:798f2b525a2e90562f1ba9da21010dde0d73730e277acaa5c52d2a6364fd3e2a", size = 87265 }, - { url = "https://files.pythonhosted.org/packages/8f/fb/44e9747558a7381ea6736e10ac2f871414007915afb94efac423e68cf441/levenshtein-0.26.1-cp311-cp311-win_amd64.whl", hash = "sha256:55b1024516c59df55f1cf1a8651659a568f2c5929d863d3da1ce8893753153bd", size = 98518 }, - { url = "https://files.pythonhosted.org/packages/04/90/c476a74d8ec25d680b9cbf51966d638623a82a2fd4e99b988a383f22a681/levenshtein-0.26.1-cp311-cp311-win_arm64.whl", hash = "sha256:e52575cbc6b9764ea138a6f82d73d3b1bc685fe62e207ff46a963d4c773799f6", size = 88086 }, - { url = "https://files.pythonhosted.org/packages/4c/53/3685ee7fbe9b8eb4b82d8045255e59dd6943f94e8091697ef3808e7ecf63/levenshtein-0.26.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cc741ca406d3704dc331a69c04b061fc952509a069b79cab8287413f434684bd", size = 176447 }, - { url = "https://files.pythonhosted.org/packages/82/7f/7d6fe9b76bd030200f8f9b162f3de862d597804d292af292ec3ce9ae8bee/levenshtein-0.26.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:821ace3b4e1c2e02b43cf5dc61aac2ea43bdb39837ac890919c225a2c3f2fea4", size = 157589 }, - { url = "https://files.pythonhosted.org/packages/bc/d3/44539e952df93c5d88a95a0edff34af38e4f87330a76e8335bfe2c0f31bf/levenshtein-0.26.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92694c9396f55d4c91087efacf81297bef152893806fc54c289fc0254b45384", size = 153306 }, - { url = "https://files.pythonhosted.org/packages/ba/fe/21443c0c50824314e2d2ce7e1e9cd11d21b3643f3c14da156b15b4d399c7/levenshtein-0.26.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:51ba374de7a1797d04a14a4f0ad3602d2d71fef4206bb20a6baaa6b6a502da58", size = 184409 }, - { url = "https://files.pythonhosted.org/packages/f0/7b/c95066c64bb18628cf7488e0dd6aec2b7cbda307d93ba9ede68a21af2a7b/levenshtein-0.26.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f7aa5c3327dda4ef952769bacec09c09ff5bf426e07fdc94478c37955681885b", size = 193134 }, - { url = "https://files.pythonhosted.org/packages/36/22/5f9760b135bdefb8cf8d663890756136754db03214f929b73185dfa33f05/levenshtein-0.26.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33e2517e8d3c221de2d1183f400aed64211fcfc77077b291ed9f3bb64f141cdc", size = 162266 }, - { url = "https://files.pythonhosted.org/packages/11/50/6b1a5f3600caae40db0928f6775d7efc62c13dec2407d3d540bc4afdb72c/levenshtein-0.26.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9092b622765c7649dd1d8af0f43354723dd6f4e570ac079ffd90b41033957438", size = 246339 }, - { url = "https://files.pythonhosted.org/packages/26/eb/ede282fcb495570898b39a0d2f21bbc9be5587d604c93a518ece80f3e7dc/levenshtein-0.26.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fc16796c85d7d8b259881d59cc8b5e22e940901928c2ff6924b2c967924e8a0b", size = 1077937 }, - { url = "https://files.pythonhosted.org/packages/35/41/eebe1c4a75f592d9bdc3c2595418f083bcad747e0aec52a1a9ffaae93f5c/levenshtein-0.26.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4370733967f5994ceeed8dc211089bedd45832ee688cecea17bfd35a9eb22b9", size = 1330607 }, - { url = "https://files.pythonhosted.org/packages/12/8e/4d34b1857adfd69c2a72d84bca1b8538d4cfaaf6fddd8599573f4281a9d1/levenshtein-0.26.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3535ecfd88c9b283976b5bc61265855f59bba361881e92ed2b5367b6990c93fe", size = 1197505 }, - { url = "https://files.pythonhosted.org/packages/c0/7b/6afcda1b0a0622cedaa4f7a5b3507c2384a7358fc051ccf619e5d2453bf2/levenshtein-0.26.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:90236e93d98bdfd708883a6767826fafd976dac8af8fc4a0fb423d4fa08e1bf0", size = 1352832 }, - { url = "https://files.pythonhosted.org/packages/21/5e/0ed4e7b5c820b6bc40e2c391633292c3666400339042a3d306f0dc8fdcb4/levenshtein-0.26.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:04b7cabb82edf566b1579b3ed60aac0eec116655af75a3c551fee8754ffce2ea", size = 1135970 }, - { url = "https://files.pythonhosted.org/packages/c9/91/3ff1abacb58642749dfd130ad855370e01b9c7aeaa73801964361f6e355f/levenshtein-0.26.1-cp312-cp312-win32.whl", hash = "sha256:ae382af8c76f6d2a040c0d9ca978baf461702ceb3f79a0a3f6da8d596a484c5b", size = 87599 }, - { url = "https://files.pythonhosted.org/packages/7d/f9/727f3ba7843a3fb2a0f3db825358beea2a52bc96258874ee80cb2e5ecabb/levenshtein-0.26.1-cp312-cp312-win_amd64.whl", hash = "sha256:fd091209798cfdce53746f5769987b4108fe941c54fb2e058c016ffc47872918", size = 98809 }, - { url = "https://files.pythonhosted.org/packages/d4/f4/f87f19222d279dbac429b9bc7ccae271d900fd9c48a581b8bc180ba6cd09/levenshtein-0.26.1-cp312-cp312-win_arm64.whl", hash = "sha256:7e82f2ea44a81ad6b30d92a110e04cd3c8c7c6034b629aca30a3067fa174ae89", size = 88227 }, -] - -[[package]] -name = "litellm" -version = "1.72.6.post2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohttp" }, - { name = "click" }, - { name = "httpx" }, - { name = "importlib-metadata" }, - { name = "jinja2" }, - { name = "jsonschema" }, - { name = "openai" }, - { name = "pydantic" }, - { name = "python-dotenv" }, - { name = "tiktoken" }, - { name = "tokenizers" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8f/50/e594d8978362796e44c9643befac6dd27dcc113aa700723697bae849ed72/litellm-1.72.6.post2.tar.gz", hash = "sha256:24dbe0efaeca0712d2e18795a6734d1678af086ed9ea1893721c426fe984398d", size = 8363431 } - [[package]] name = "loguru" version = "0.7.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, - { name = "win32-setctime", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "win32-setctime", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559 } wheels = [ @@ -2098,44 +1651,40 @@ wheels = [ [[package]] name = "lxml" -version = "5.4.0" +version = "6.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/76/3d/14e82fc7c8fb1b7761f7e748fd47e2ec8276d137b6acfe5a4bb73853e08f/lxml-5.4.0.tar.gz", hash = "sha256:d12832e1dbea4be280b22fd0ea7c9b87f0d8fc51ba06e92dc62d52f804f78ebd", size = 3679479 } +sdist = { url = "https://files.pythonhosted.org/packages/c5/ed/60eb6fa2923602fba988d9ca7c5cdbd7cf25faa795162ed538b527a35411/lxml-6.0.0.tar.gz", hash = "sha256:032e65120339d44cdc3efc326c9f660f5f7205f3a535c1fdbf898b29ea01fb72", size = 4096938 } wheels = [ - { url = "https://files.pythonhosted.org/packages/81/2d/67693cc8a605a12e5975380d7ff83020dcc759351b5a066e1cced04f797b/lxml-5.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:98a3912194c079ef37e716ed228ae0dcb960992100461b704aea4e93af6b0bb9", size = 8083240 }, - { url = "https://files.pythonhosted.org/packages/73/53/b5a05ab300a808b72e848efd152fe9c022c0181b0a70b8bca1199f1bed26/lxml-5.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0ea0252b51d296a75f6118ed0d8696888e7403408ad42345d7dfd0d1e93309a7", size = 4387685 }, - { url = "https://files.pythonhosted.org/packages/d8/cb/1a3879c5f512bdcd32995c301886fe082b2edd83c87d41b6d42d89b4ea4d/lxml-5.4.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b92b69441d1bd39f4940f9eadfa417a25862242ca2c396b406f9272ef09cdcaa", size = 4991164 }, - { url = "https://files.pythonhosted.org/packages/f9/94/bbc66e42559f9d04857071e3b3d0c9abd88579367fd2588a4042f641f57e/lxml-5.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20e16c08254b9b6466526bc1828d9370ee6c0d60a4b64836bc3ac2917d1e16df", size = 4746206 }, - { url = "https://files.pythonhosted.org/packages/66/95/34b0679bee435da2d7cae895731700e519a8dfcab499c21662ebe671603e/lxml-5.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7605c1c32c3d6e8c990dd28a0970a3cbbf1429d5b92279e37fda05fb0c92190e", size = 5342144 }, - { url = "https://files.pythonhosted.org/packages/e0/5d/abfcc6ab2fa0be72b2ba938abdae1f7cad4c632f8d552683ea295d55adfb/lxml-5.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ecf4c4b83f1ab3d5a7ace10bafcb6f11df6156857a3c418244cef41ca9fa3e44", size = 4825124 }, - { url = "https://files.pythonhosted.org/packages/5a/78/6bd33186c8863b36e084f294fc0a5e5eefe77af95f0663ef33809cc1c8aa/lxml-5.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cef4feae82709eed352cd7e97ae062ef6ae9c7b5dbe3663f104cd2c0e8d94ba", size = 4876520 }, - { url = "https://files.pythonhosted.org/packages/3b/74/4d7ad4839bd0fc64e3d12da74fc9a193febb0fae0ba6ebd5149d4c23176a/lxml-5.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:df53330a3bff250f10472ce96a9af28628ff1f4efc51ccba351a8820bca2a8ba", size = 4765016 }, - { url = "https://files.pythonhosted.org/packages/24/0d/0a98ed1f2471911dadfc541003ac6dd6879fc87b15e1143743ca20f3e973/lxml-5.4.0-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:aefe1a7cb852fa61150fcb21a8c8fcea7b58c4cb11fbe59c97a0a4b31cae3c8c", size = 5362884 }, - { url = "https://files.pythonhosted.org/packages/48/de/d4f7e4c39740a6610f0f6959052b547478107967362e8424e1163ec37ae8/lxml-5.4.0-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:ef5a7178fcc73b7d8c07229e89f8eb45b2908a9238eb90dcfc46571ccf0383b8", size = 4902690 }, - { url = "https://files.pythonhosted.org/packages/07/8c/61763abd242af84f355ca4ef1ee096d3c1b7514819564cce70fd18c22e9a/lxml-5.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d2ed1b3cb9ff1c10e6e8b00941bb2e5bb568b307bfc6b17dffbbe8be5eecba86", size = 4944418 }, - { url = "https://files.pythonhosted.org/packages/f9/c5/6d7e3b63e7e282619193961a570c0a4c8a57fe820f07ca3fe2f6bd86608a/lxml-5.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:72ac9762a9f8ce74c9eed4a4e74306f2f18613a6b71fa065495a67ac227b3056", size = 4827092 }, - { url = "https://files.pythonhosted.org/packages/71/4a/e60a306df54680b103348545706a98a7514a42c8b4fbfdcaa608567bb065/lxml-5.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f5cb182f6396706dc6cc1896dd02b1c889d644c081b0cdec38747573db88a7d7", size = 5418231 }, - { url = "https://files.pythonhosted.org/packages/27/f2/9754aacd6016c930875854f08ac4b192a47fe19565f776a64004aa167521/lxml-5.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:3a3178b4873df8ef9457a4875703488eb1622632a9cee6d76464b60e90adbfcd", size = 5261798 }, - { url = "https://files.pythonhosted.org/packages/38/a2/0c49ec6941428b1bd4f280650d7b11a0f91ace9db7de32eb7aa23bcb39ff/lxml-5.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e094ec83694b59d263802ed03a8384594fcce477ce484b0cbcd0008a211ca751", size = 4988195 }, - { url = "https://files.pythonhosted.org/packages/7a/75/87a3963a08eafc46a86c1131c6e28a4de103ba30b5ae903114177352a3d7/lxml-5.4.0-cp311-cp311-win32.whl", hash = "sha256:4329422de653cdb2b72afa39b0aa04252fca9071550044904b2e7036d9d97fe4", size = 3474243 }, - { url = "https://files.pythonhosted.org/packages/fa/f9/1f0964c4f6c2be861c50db380c554fb8befbea98c6404744ce243a3c87ef/lxml-5.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd3be6481ef54b8cfd0e1e953323b7aa9d9789b94842d0e5b142ef4bb7999539", size = 3815197 }, - { url = "https://files.pythonhosted.org/packages/f8/4c/d101ace719ca6a4ec043eb516fcfcb1b396a9fccc4fcd9ef593df34ba0d5/lxml-5.4.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5aff6f3e818e6bdbbb38e5967520f174b18f539c2b9de867b1e7fde6f8d95a4", size = 8127392 }, - { url = "https://files.pythonhosted.org/packages/11/84/beddae0cec4dd9ddf46abf156f0af451c13019a0fa25d7445b655ba5ccb7/lxml-5.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942a5d73f739ad7c452bf739a62a0f83e2578afd6b8e5406308731f4ce78b16d", size = 4415103 }, - { url = "https://files.pythonhosted.org/packages/d0/25/d0d93a4e763f0462cccd2b8a665bf1e4343dd788c76dcfefa289d46a38a9/lxml-5.4.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:460508a4b07364d6abf53acaa0a90b6d370fafde5693ef37602566613a9b0779", size = 5024224 }, - { url = "https://files.pythonhosted.org/packages/31/ce/1df18fb8f7946e7f3388af378b1f34fcf253b94b9feedb2cec5969da8012/lxml-5.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:529024ab3a505fed78fe3cc5ddc079464e709f6c892733e3f5842007cec8ac6e", size = 4769913 }, - { url = "https://files.pythonhosted.org/packages/4e/62/f4a6c60ae7c40d43657f552f3045df05118636be1165b906d3423790447f/lxml-5.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ca56ebc2c474e8f3d5761debfd9283b8b18c76c4fc0967b74aeafba1f5647f9", size = 5290441 }, - { url = "https://files.pythonhosted.org/packages/9e/aa/04f00009e1e3a77838c7fc948f161b5d2d5de1136b2b81c712a263829ea4/lxml-5.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a81e1196f0a5b4167a8dafe3a66aa67c4addac1b22dc47947abd5d5c7a3f24b5", size = 4820165 }, - { url = "https://files.pythonhosted.org/packages/c9/1f/e0b2f61fa2404bf0f1fdf1898377e5bd1b74cc9b2cf2c6ba8509b8f27990/lxml-5.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00b8686694423ddae324cf614e1b9659c2edb754de617703c3d29ff568448df5", size = 4932580 }, - { url = "https://files.pythonhosted.org/packages/24/a2/8263f351b4ffe0ed3e32ea7b7830f845c795349034f912f490180d88a877/lxml-5.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c5681160758d3f6ac5b4fea370495c48aac0989d6a0f01bb9a72ad8ef5ab75c4", size = 4759493 }, - { url = "https://files.pythonhosted.org/packages/05/00/41db052f279995c0e35c79d0f0fc9f8122d5b5e9630139c592a0b58c71b4/lxml-5.4.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:2dc191e60425ad70e75a68c9fd90ab284df64d9cd410ba8d2b641c0c45bc006e", size = 5324679 }, - { url = "https://files.pythonhosted.org/packages/1d/be/ee99e6314cdef4587617d3b3b745f9356d9b7dd12a9663c5f3b5734b64ba/lxml-5.4.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:67f779374c6b9753ae0a0195a892a1c234ce8416e4448fe1e9f34746482070a7", size = 4890691 }, - { url = "https://files.pythonhosted.org/packages/ad/36/239820114bf1d71f38f12208b9c58dec033cbcf80101cde006b9bde5cffd/lxml-5.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:79d5bfa9c1b455336f52343130b2067164040604e41f6dc4d8313867ed540079", size = 4955075 }, - { url = "https://files.pythonhosted.org/packages/d4/e1/1b795cc0b174efc9e13dbd078a9ff79a58728a033142bc6d70a1ee8fc34d/lxml-5.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3d3c30ba1c9b48c68489dc1829a6eede9873f52edca1dda900066542528d6b20", size = 4838680 }, - { url = "https://files.pythonhosted.org/packages/72/48/3c198455ca108cec5ae3662ae8acd7fd99476812fd712bb17f1b39a0b589/lxml-5.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1af80c6316ae68aded77e91cd9d80648f7dd40406cef73df841aa3c36f6907c8", size = 5391253 }, - { url = "https://files.pythonhosted.org/packages/d6/10/5bf51858971c51ec96cfc13e800a9951f3fd501686f4c18d7d84fe2d6352/lxml-5.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4d885698f5019abe0de3d352caf9466d5de2baded00a06ef3f1216c1a58ae78f", size = 5261651 }, - { url = "https://files.pythonhosted.org/packages/2b/11/06710dd809205377da380546f91d2ac94bad9ff735a72b64ec029f706c85/lxml-5.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea53d51859b6c64e7c51d522c03cc2c48b9b5d6172126854cc7f01aa11f52bc", size = 5024315 }, - { url = "https://files.pythonhosted.org/packages/f5/b0/15b6217834b5e3a59ebf7f53125e08e318030e8cc0d7310355e6edac98ef/lxml-5.4.0-cp312-cp312-win32.whl", hash = "sha256:d90b729fd2732df28130c064aac9bb8aff14ba20baa4aee7bd0795ff1187545f", size = 3486149 }, - { url = "https://files.pythonhosted.org/packages/91/1e/05ddcb57ad2f3069101611bd5f5084157d90861a2ef460bf42f45cced944/lxml-5.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1dc4ca99e89c335a7ed47d38964abcb36c5910790f9bd106f2a8fa2ee0b909d2", size = 3817095 }, + { url = "https://files.pythonhosted.org/packages/7c/23/828d4cc7da96c611ec0ce6147bbcea2fdbde023dc995a165afa512399bbf/lxml-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4ee56288d0df919e4aac43b539dd0e34bb55d6a12a6562038e8d6f3ed07f9e36", size = 8438217 }, + { url = "https://files.pythonhosted.org/packages/f1/33/5ac521212c5bcb097d573145d54b2b4a3c9766cda88af5a0e91f66037c6e/lxml-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b8dd6dd0e9c1992613ccda2bcb74fc9d49159dbe0f0ca4753f37527749885c25", size = 4590317 }, + { url = "https://files.pythonhosted.org/packages/2b/2e/45b7ca8bee304c07f54933c37afe7dd4d39ff61ba2757f519dcc71bc5d44/lxml-6.0.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:d7ae472f74afcc47320238b5dbfd363aba111a525943c8a34a1b657c6be934c3", size = 5221628 }, + { url = "https://files.pythonhosted.org/packages/32/23/526d19f7eb2b85da1f62cffb2556f647b049ebe2a5aa8d4d41b1fb2c7d36/lxml-6.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5592401cdf3dc682194727c1ddaa8aa0f3ddc57ca64fd03226a430b955eab6f6", size = 4949429 }, + { url = "https://files.pythonhosted.org/packages/ac/cc/f6be27a5c656a43a5344e064d9ae004d4dcb1d3c9d4f323c8189ddfe4d13/lxml-6.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58ffd35bd5425c3c3b9692d078bf7ab851441434531a7e517c4984d5634cd65b", size = 5087909 }, + { url = "https://files.pythonhosted.org/packages/3b/e6/8ec91b5bfbe6972458bc105aeb42088e50e4b23777170404aab5dfb0c62d/lxml-6.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f720a14aa102a38907c6d5030e3d66b3b680c3e6f6bc95473931ea3c00c59967", size = 5031713 }, + { url = "https://files.pythonhosted.org/packages/33/cf/05e78e613840a40e5be3e40d892c48ad3e475804db23d4bad751b8cadb9b/lxml-6.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c2a5e8d207311a0170aca0eb6b160af91adc29ec121832e4ac151a57743a1e1e", size = 5232417 }, + { url = "https://files.pythonhosted.org/packages/ac/8c/6b306b3e35c59d5f0b32e3b9b6b3b0739b32c0dc42a295415ba111e76495/lxml-6.0.0-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:2dd1cc3ea7e60bfb31ff32cafe07e24839df573a5e7c2d33304082a5019bcd58", size = 4681443 }, + { url = "https://files.pythonhosted.org/packages/59/43/0bd96bece5f7eea14b7220476835a60d2b27f8e9ca99c175f37c085cb154/lxml-6.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cfcf84f1defed7e5798ef4f88aa25fcc52d279be731ce904789aa7ccfb7e8d2", size = 5074542 }, + { url = "https://files.pythonhosted.org/packages/e2/3d/32103036287a8ca012d8518071f8852c68f2b3bfe048cef2a0202eb05910/lxml-6.0.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:a52a4704811e2623b0324a18d41ad4b9fabf43ce5ff99b14e40a520e2190c851", size = 4729471 }, + { url = "https://files.pythonhosted.org/packages/ca/a8/7be5d17df12d637d81854bd8648cd329f29640a61e9a72a3f77add4a311b/lxml-6.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c16304bba98f48a28ae10e32a8e75c349dd742c45156f297e16eeb1ba9287a1f", size = 5256285 }, + { url = "https://files.pythonhosted.org/packages/cd/d0/6cb96174c25e0d749932557c8d51d60c6e292c877b46fae616afa23ed31a/lxml-6.0.0-cp311-cp311-win32.whl", hash = "sha256:f8d19565ae3eb956d84da3ef367aa7def14a2735d05bd275cd54c0301f0d0d6c", size = 3612004 }, + { url = "https://files.pythonhosted.org/packages/ca/77/6ad43b165dfc6dead001410adeb45e88597b25185f4479b7ca3b16a5808f/lxml-6.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b2d71cdefda9424adff9a3607ba5bbfc60ee972d73c21c7e3c19e71037574816", size = 4003470 }, + { url = "https://files.pythonhosted.org/packages/a0/bc/4c50ec0eb14f932a18efc34fc86ee936a66c0eb5f2fe065744a2da8a68b2/lxml-6.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:8a2e76efbf8772add72d002d67a4c3d0958638696f541734304c7f28217a9cab", size = 3682477 }, + { url = "https://files.pythonhosted.org/packages/89/c3/d01d735c298d7e0ddcedf6f028bf556577e5ab4f4da45175ecd909c79378/lxml-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78718d8454a6e928470d511bf8ac93f469283a45c354995f7d19e77292f26108", size = 8429515 }, + { url = "https://files.pythonhosted.org/packages/06/37/0e3eae3043d366b73da55a86274a590bae76dc45aa004b7042e6f97803b1/lxml-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:84ef591495ffd3f9dcabffd6391db7bb70d7230b5c35ef5148354a134f56f2be", size = 4601387 }, + { url = "https://files.pythonhosted.org/packages/a3/28/e1a9a881e6d6e29dda13d633885d13acb0058f65e95da67841c8dd02b4a8/lxml-6.0.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2930aa001a3776c3e2601cb8e0a15d21b8270528d89cc308be4843ade546b9ab", size = 5228928 }, + { url = "https://files.pythonhosted.org/packages/9a/55/2cb24ea48aa30c99f805921c1c7860c1f45c0e811e44ee4e6a155668de06/lxml-6.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:219e0431ea8006e15005767f0351e3f7f9143e793e58519dc97fe9e07fae5563", size = 4952289 }, + { url = "https://files.pythonhosted.org/packages/31/c0/b25d9528df296b9a3306ba21ff982fc5b698c45ab78b94d18c2d6ae71fd9/lxml-6.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bd5913b4972681ffc9718bc2d4c53cde39ef81415e1671ff93e9aa30b46595e7", size = 5111310 }, + { url = "https://files.pythonhosted.org/packages/e9/af/681a8b3e4f668bea6e6514cbcb297beb6de2b641e70f09d3d78655f4f44c/lxml-6.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:390240baeb9f415a82eefc2e13285016f9c8b5ad71ec80574ae8fa9605093cd7", size = 5025457 }, + { url = "https://files.pythonhosted.org/packages/99/b6/3a7971aa05b7be7dfebc7ab57262ec527775c2c3c5b2f43675cac0458cad/lxml-6.0.0-cp312-cp312-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d6e200909a119626744dd81bae409fc44134389e03fbf1d68ed2a55a2fb10991", size = 5657016 }, + { url = "https://files.pythonhosted.org/packages/69/f8/693b1a10a891197143c0673fcce5b75fc69132afa81a36e4568c12c8faba/lxml-6.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca50bd612438258a91b5b3788c6621c1f05c8c478e7951899f492be42defc0da", size = 5257565 }, + { url = "https://files.pythonhosted.org/packages/a8/96/e08ff98f2c6426c98c8964513c5dab8d6eb81dadcd0af6f0c538ada78d33/lxml-6.0.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:c24b8efd9c0f62bad0439283c2c795ef916c5a6b75f03c17799775c7ae3c0c9e", size = 4713390 }, + { url = "https://files.pythonhosted.org/packages/a8/83/6184aba6cc94d7413959f6f8f54807dc318fdcd4985c347fe3ea6937f772/lxml-6.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afd27d8629ae94c5d863e32ab0e1d5590371d296b87dae0a751fb22bf3685741", size = 5066103 }, + { url = "https://files.pythonhosted.org/packages/ee/01/8bf1f4035852d0ff2e36a4d9aacdbcc57e93a6cd35a54e05fa984cdf73ab/lxml-6.0.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:54c4855eabd9fc29707d30141be99e5cd1102e7d2258d2892314cf4c110726c3", size = 4791428 }, + { url = "https://files.pythonhosted.org/packages/29/31/c0267d03b16954a85ed6b065116b621d37f559553d9339c7dcc4943a76f1/lxml-6.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c907516d49f77f6cd8ead1322198bdfd902003c3c330c77a1c5f3cc32a0e4d16", size = 5678523 }, + { url = "https://files.pythonhosted.org/packages/5c/f7/5495829a864bc5f8b0798d2b52a807c89966523140f3d6fa3a58ab6720ea/lxml-6.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36531f81c8214e293097cd2b7873f178997dae33d3667caaae8bdfb9666b76c0", size = 5281290 }, + { url = "https://files.pythonhosted.org/packages/79/56/6b8edb79d9ed294ccc4e881f4db1023af56ba451909b9ce79f2a2cd7c532/lxml-6.0.0-cp312-cp312-win32.whl", hash = "sha256:690b20e3388a7ec98e899fd54c924e50ba6693874aa65ef9cb53de7f7de9d64a", size = 3613495 }, + { url = "https://files.pythonhosted.org/packages/0b/1e/cc32034b40ad6af80b6fd9b66301fc0f180f300002e5c3eb5a6110a93317/lxml-6.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:310b719b695b3dd442cdfbbe64936b2f2e231bb91d998e99e6f0daf991a3eba3", size = 4014711 }, + { url = "https://files.pythonhosted.org/packages/55/10/dc8e5290ae4c94bdc1a4c55865be7e1f31dfd857a88b21cbba68b5fea61b/lxml-6.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:8cb26f51c82d77483cdcd2b4a53cda55bbee29b3c2f3ddeb47182a2a9064e4eb", size = 3674431 }, ] [package.optional-dependencies] @@ -2167,15 +1716,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, ] -[[package]] -name = "marko" -version = "2.1.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/dc/c8cadbd83de1b38d95a48568b445a5553005ebdd32e00a333ca940113db4/marko-2.1.4.tar.gz", hash = "sha256:dd7d66f3706732bf8f994790e674649a4fd0a6c67f16b80246f30de8e16a1eac", size = 142795 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c3/66/49e3691d14898fb6e34ccb337c7677dfb7e18269ed170f12e4b85315eae6/marko-2.1.4-py3-none-any.whl", hash = "sha256:81c2b9f570ca485bc356678d9ba1a1b3eb78b4a315d01f3ded25442fdc796990", size = 42186 }, -] - [[package]] name = "markupsafe" version = "3.0.2" @@ -2206,14 +1746,14 @@ wheels = [ [[package]] name = "marshmallow" -version = "3.26.1" +version = "3.26.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "packaging" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ab/5e/5e53d26b42ab75491cda89b871dab9e97c840bf12c63ec58a1919710cd06/marshmallow-3.26.1.tar.gz", hash = "sha256:e6d8affb6cb61d39d26402096dc0aee12d5a26d490a121f118d2e81dc0719dc6", size = 221825 } +sdist = { url = "https://files.pythonhosted.org/packages/ed/3a/b392ca6582ce5c2e515a8ca365f89b6e631d864a80ecdc72e0bc1bf3aec6/marshmallow-3.26.0.tar.gz", hash = "sha256:eb36762a1cc76d7abf831e18a3a1b26d3d481bbc74581b8e532a3d3a8115e1cb", size = 221490 } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/75/51952c7b2d3873b44a0028b1bd26a25078c18f92f256608e8d1dc61b39fd/marshmallow-3.26.1-py3-none-any.whl", hash = "sha256:3350409f20a70a7e4e11a27661187b77cdcaeb20abca41c1454fe33636bea09c", size = 50878 }, + { url = "https://files.pythonhosted.org/packages/d6/0d/80d7071803df1957c304bc096a714334dda7eb41ecfdd28dcfb49b1cde0e/marshmallow-3.26.0-py3-none-any.whl", hash = "sha256:1287bca04e6a5f4094822ac153c03da5e214a0a60bcd557b140f3e66991b8ca1", size = 50846 }, ] [[package]] @@ -2237,15 +1777,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, ] -[[package]] -name = "mistune" -version = "3.1.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c4/79/bda47f7dd7c3c55770478d6d02c9960c430b0cf1773b72366ff89126ea31/mistune-3.1.3.tar.gz", hash = "sha256:a7035c21782b2becb6be62f8f25d3df81ccb4d6fa477a6525b15af06539f02a0", size = 94347 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/01/4d/23c4e4f09da849e127e9f123241946c23c1e30f45a88366879e064211815/mistune-3.1.3-py3-none-any.whl", hash = "sha256:1a32314113cff28aa6432e99e522677c8587fd83e3d51c29b82a52409c842bd9", size = 53410 }, -] - [[package]] name = "moviepy" version = "2.2.1" @@ -2264,96 +1795,43 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9a/73/7d3b2010baa0b5eb1e4dfa9e4385e89b6716be76f2fa21a6c0fe34b68e5a/moviepy-2.2.1-py3-none-any.whl", hash = "sha256:6b56803fec2ac54b557404126ac1160e65448e03798fa282bd23e8fab3795060", size = 129871 }, ] -[[package]] -name = "mpire" -version = "2.10.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pygments" }, - { name = "pywin32", marker = "platform_system == 'Windows'" }, - { name = "tqdm" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", hash = "sha256:f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97", size = 271270 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/20/14/1db1729ad6db4999c3a16c47937d601fcb909aaa4224f5eca5a2f145a605/mpire-2.10.2-py3-none-any.whl", hash = "sha256:d627707f7a8d02aa4c7f7d59de399dec5290945ddf7fbd36cbb1d6ebb37a51fb", size = 272756 }, -] - -[package.optional-dependencies] -dill = [ - { name = "multiprocess" }, -] - -[[package]] -name = "mpmath" -version = "1.3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198 }, -] - [[package]] name = "multidict" -version = "6.5.0" +version = "6.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/46/b5/59f27b4ce9951a4bce56b88ba5ff5159486797ab18863f2b4c1c5e8465bd/multidict-6.5.0.tar.gz", hash = "sha256:942bd8002492ba819426a8d7aefde3189c1b87099cdf18aaaefefcf7f3f7b6d2", size = 98512 } +sdist = { url = "https://files.pythonhosted.org/packages/d6/be/504b89a5e9ca731cd47487e91c469064f8ae5af93b7259758dcfc2b9c848/multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a", size = 64002 } wheels = [ - { url = "https://files.pythonhosted.org/packages/75/ba/484f8e96ee58ec4fef42650eb9dbbedb24f9bc155780888398a4725d2270/multidict-6.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8b4bf6bb15a05796a07a248084e3e46e032860c899c7a9b981030e61368dba95", size = 73283 }, - { url = "https://files.pythonhosted.org/packages/71/48/01d62ea6199d76934c87746695b3ed16aeedfdd564e8d89184577037baac/multidict-6.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46bb05d50219655c42a4b8fcda9c7ee658a09adbb719c48e65a20284e36328ea", size = 42937 }, - { url = "https://files.pythonhosted.org/packages/da/cf/bb462d920f26d9e2e0aff8a78aeb06af1225b826e9a5468870c57591910a/multidict-6.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:54f524d73f4d54e87e03c98f6af601af4777e4668a52b1bd2ae0a4d6fc7b392b", size = 42748 }, - { url = "https://files.pythonhosted.org/packages/cd/b1/d5c11ea0fdad68d3ed45f0e2527de6496d2fac8afe6b8ca6d407c20ad00f/multidict-6.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:529b03600466480ecc502000d62e54f185a884ed4570dee90d9a273ee80e37b5", size = 236448 }, - { url = "https://files.pythonhosted.org/packages/fc/69/c3ceb264994f5b338c812911a8d660084f37779daef298fc30bd817f75c7/multidict-6.5.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:69ad681ad7c93a41ee7005cc83a144b5b34a3838bcf7261e2b5356057b0f78de", size = 228695 }, - { url = "https://files.pythonhosted.org/packages/81/3d/c23dcc0d34a35ad29974184db2878021d28fe170ecb9192be6bfee73f1f2/multidict-6.5.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fe9fada8bc0839466b09fa3f6894f003137942984843ec0c3848846329a36ae", size = 247434 }, - { url = "https://files.pythonhosted.org/packages/06/b3/06cf7a049129ff52525a859277abb5648e61d7afae7fb7ed02e3806be34e/multidict-6.5.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f94c6ea6405fcf81baef1e459b209a78cda5442e61b5b7a57ede39d99b5204a0", size = 239431 }, - { url = "https://files.pythonhosted.org/packages/8a/72/b2fe2fafa23af0c6123aebe23b4cd23fdad01dfe7009bb85624e4636d0dd/multidict-6.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ca75ad8a39ed75f079a8931435a5b51ee4c45d9b32e1740f99969a5d1cc2ee", size = 231542 }, - { url = "https://files.pythonhosted.org/packages/a1/c9/a52ca0a342a02411a31b6af197a6428a5137d805293f10946eeab614ec06/multidict-6.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:be4c08f3a2a6cc42b414496017928d95898964fed84b1b2dace0c9ee763061f9", size = 233069 }, - { url = "https://files.pythonhosted.org/packages/9b/55/a3328a3929b8e131e2678d5e65f552b0a6874fab62123e31f5a5625650b0/multidict-6.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:046a7540cfbb4d5dc846a1fd9843f3ba980c6523f2e0c5b8622b4a5c94138ae6", size = 250596 }, - { url = "https://files.pythonhosted.org/packages/6c/b8/aa3905a38a8287013aeb0a54c73f79ccd8b32d2f1d53e5934643a36502c2/multidict-6.5.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:64306121171d988af77d74be0d8c73ee1a69cf6f96aea7fa6030c88f32a152dd", size = 237858 }, - { url = "https://files.pythonhosted.org/packages/d3/eb/f11d5af028014f402e5dd01ece74533964fa4e7bfae4af4824506fa8c398/multidict-6.5.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b4ac1dd5eb0ecf6f7351d5a9137f30a83f7182209c5d37f61614dfdce5714853", size = 249175 }, - { url = "https://files.pythonhosted.org/packages/ac/57/d451905a62e5ef489cb4f92e8190d34ac5329427512afd7f893121da4e96/multidict-6.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bab4a8337235365f4111a7011a1f028826ca683834ebd12de4b85e2844359c36", size = 259532 }, - { url = "https://files.pythonhosted.org/packages/d3/90/ff82b5ac5cabe3c79c50cf62a62f3837905aa717e67b6b4b7872804f23c8/multidict-6.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a05b5604c5a75df14a63eeeca598d11b2c3745b9008539b70826ea044063a572", size = 250554 }, - { url = "https://files.pythonhosted.org/packages/d5/5a/0cabc50d4bc16e61d8b0a8a74499a1409fa7b4ef32970b7662a423781fc7/multidict-6.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:67c4a640952371c9ca65b6a710598be246ef3be5ca83ed38c16a7660d3980877", size = 248159 }, - { url = "https://files.pythonhosted.org/packages/c0/1d/adeabae0771544f140d9f42ab2c46eaf54e793325999c36106078b7f6600/multidict-6.5.0-cp311-cp311-win32.whl", hash = "sha256:fdeae096ca36c12d8aca2640b8407a9d94e961372c68435bef14e31cce726138", size = 40357 }, - { url = "https://files.pythonhosted.org/packages/e1/fe/bbd85ae65c96de5c9910c332ee1f4b7be0bf0fb21563895167bcb6502a1f/multidict-6.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:e2977ef8b7ce27723ee8c610d1bd1765da4f3fbe5a64f9bf1fd3b4770e31fbc0", size = 44432 }, - { url = "https://files.pythonhosted.org/packages/96/af/f9052d9c4e65195b210da9f7afdea06d3b7592b3221cc0ef1b407f762faa/multidict-6.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:82d0cf0ea49bae43d9e8c3851e21954eff716259ff42da401b668744d1760bcb", size = 41408 }, - { url = "https://files.pythonhosted.org/packages/0a/fa/18f4950e00924f7e84c8195f4fc303295e14df23f713d64e778b8fa8b903/multidict-6.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1bb986c8ea9d49947bc325c51eced1ada6d8d9b4c5b15fd3fcdc3c93edef5a74", size = 73474 }, - { url = "https://files.pythonhosted.org/packages/6c/66/0392a2a8948bccff57e4793c9dde3e5c088f01e8b7f8867ee58a2f187fc5/multidict-6.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:03c0923da300120830fc467e23805d63bbb4e98b94032bd863bc7797ea5fa653", size = 43741 }, - { url = "https://files.pythonhosted.org/packages/98/3e/f48487c91b2a070566cfbab876d7e1ebe7deb0a8002e4e896a97998ae066/multidict-6.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4c78d5ec00fdd35c91680ab5cf58368faad4bd1a8721f87127326270248de9bc", size = 42143 }, - { url = "https://files.pythonhosted.org/packages/3f/49/439c6cc1cd00365cf561bdd3579cc3fa1a0d38effb3a59b8d9562839197f/multidict-6.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aadc3cb78be90a887f8f6b73945b840da44b4a483d1c9750459ae69687940c97", size = 239303 }, - { url = "https://files.pythonhosted.org/packages/c4/24/491786269e90081cb536e4d7429508725bc92ece176d1204a4449de7c41c/multidict-6.5.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b02e1ca495d71e07e652e4cef91adae3bf7ae4493507a263f56e617de65dafc", size = 236913 }, - { url = "https://files.pythonhosted.org/packages/e8/76/bbe2558b820ebeca8a317ab034541790e8160ca4b1e450415383ac69b339/multidict-6.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7fe92a62326eef351668eec4e2dfc494927764a0840a1895cff16707fceffcd3", size = 250752 }, - { url = "https://files.pythonhosted.org/packages/3e/e3/3977f2c1123f553ceff9f53cd4de04be2c1912333c6fabbcd51531655476/multidict-6.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7673ee4f63879ecd526488deb1989041abcb101b2d30a9165e1e90c489f3f7fb", size = 243937 }, - { url = "https://files.pythonhosted.org/packages/b6/b8/7a6e9c13c79709cdd2f22ee849f058e6da76892d141a67acc0e6c30d845c/multidict-6.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa097ae2a29f573de7e2d86620cbdda5676d27772d4ed2669cfa9961a0d73955", size = 237419 }, - { url = "https://files.pythonhosted.org/packages/84/9d/8557f5e88da71bc7e7a8ace1ada4c28197f3bfdc2dd6e51d3b88f2e16e8e/multidict-6.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:300da0fa4f8457d9c4bd579695496116563409e676ac79b5e4dca18e49d1c308", size = 237222 }, - { url = "https://files.pythonhosted.org/packages/a3/3b/8f023ad60e7969cb6bc0683738d0e1618f5ff5723d6d2d7818dc6df6ad3d/multidict-6.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9a19bd108c35877b57393243d392d024cfbfdefe759fd137abb98f6fc910b64c", size = 247861 }, - { url = "https://files.pythonhosted.org/packages/af/1c/9cf5a099ce7e3189906cf5daa72c44ee962dcb4c1983659f3a6f8a7446ab/multidict-6.5.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f32a1777465a35c35ddbbd7fc1293077938a69402fcc59e40b2846d04a120dd", size = 243917 }, - { url = "https://files.pythonhosted.org/packages/6c/bb/88ee66ebeef56868044bac58feb1cc25658bff27b20e3cfc464edc181287/multidict-6.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9cc1e10c14ce8112d1e6d8971fe3cdbe13e314f68bea0e727429249d4a6ce164", size = 249214 }, - { url = "https://files.pythonhosted.org/packages/3e/ec/a90e88cc4a1309f33088ab1cdd5c0487718f49dfb82c5ffc845bb17c1973/multidict-6.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e95c5e07a06594bdc288117ca90e89156aee8cb2d7c330b920d9c3dd19c05414", size = 258682 }, - { url = "https://files.pythonhosted.org/packages/d2/d8/16dd69a6811920a31f4e06114ebe67b1cd922c8b05c9c82b050706d0b6fe/multidict-6.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:40ff26f58323795f5cd2855e2718a1720a1123fb90df4553426f0efd76135462", size = 254254 }, - { url = "https://files.pythonhosted.org/packages/ac/a8/90193a5f5ca1bdbf92633d69a25a2ef9bcac7b412b8d48c84d01a2732518/multidict-6.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:76803a29fd71869a8b59c2118c9dcfb3b8f9c8723e2cce6baeb20705459505cf", size = 247741 }, - { url = "https://files.pythonhosted.org/packages/cd/43/29c7a747153c05b41d1f67455426af39ed88d6de3f21c232b8f2724bde13/multidict-6.5.0-cp312-cp312-win32.whl", hash = "sha256:df7ecbc65a53a2ce1b3a0c82e6ad1a43dcfe7c6137733f9176a92516b9f5b851", size = 41049 }, - { url = "https://files.pythonhosted.org/packages/1e/e8/8f3fc32b7e901f3a2719764d64aeaf6ae77b4ba961f1c3a3cf3867766636/multidict-6.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:0ec1c3fbbb0b655a6540bce408f48b9a7474fd94ed657dcd2e890671fefa7743", size = 44700 }, - { url = "https://files.pythonhosted.org/packages/24/e4/e250806adc98d524d41e69c8d4a42bc3513464adb88cb96224df12928617/multidict-6.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:2d24a00d34808b22c1f15902899b9d82d0faeca9f56281641c791d8605eacd35", size = 41703 }, - { url = "https://files.pythonhosted.org/packages/44/d8/45e8fc9892a7386d074941429e033adb4640e59ff0780d96a8cf46fe788e/multidict-6.5.0-py3-none-any.whl", hash = "sha256:5634b35f225977605385f56153bd95a7133faffc0ffe12ad26e10517537e8dfc", size = 12181 }, -] - -[[package]] -name = "multiprocess" -version = "0.70.18" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "dill" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/72/fd/2ae3826f5be24c6ed87266bc4e59c46ea5b059a103f3d7e7eb76a52aeecb/multiprocess-0.70.18.tar.gz", hash = "sha256:f9597128e6b3e67b23956da07cf3d2e5cba79e2f4e0fba8d7903636663ec6d0d", size = 1798503 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/55/4d/9af0d1279c84618bcd35bf5fd7e371657358c7b0a523e54a9cffb87461f8/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b8940ae30139e04b076da6c5b83e9398585ebdf0f2ad3250673fef5b2ff06d6", size = 144695 }, - { url = "https://files.pythonhosted.org/packages/17/bf/87323e79dd0562474fad3373c21c66bc6c3c9963b68eb2a209deb4c8575e/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0929ba95831adb938edbd5fb801ac45e705ecad9d100b3e653946b7716cb6bd3", size = 144742 }, - { url = "https://files.pythonhosted.org/packages/dd/74/cb8c831e58dc6d5cf450b17c7db87f14294a1df52eb391da948b5e0a0b94/multiprocess-0.70.18-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4d77f8e4bfe6c6e2e661925bbf9aed4d5ade9a1c6502d5dfc10129b9d1141797", size = 144745 }, - { url = "https://files.pythonhosted.org/packages/ba/d8/0cba6cf51a1a31f20471fbc823a716170c73012ddc4fb85d706630ed6e8f/multiprocess-0.70.18-py310-none-any.whl", hash = "sha256:60c194974c31784019c1f459d984e8f33ee48f10fcf42c309ba97b30d9bd53ea", size = 134948 }, - { url = "https://files.pythonhosted.org/packages/4b/88/9039f2fed1012ef584751d4ceff9ab4a51e5ae264898f0b7cbf44340a859/multiprocess-0.70.18-py311-none-any.whl", hash = "sha256:5aa6eef98e691281b3ad923be2832bf1c55dd2c859acd73e5ec53a66aae06a1d", size = 144462 }, - { url = "https://files.pythonhosted.org/packages/bf/b6/5f922792be93b82ec6b5f270bbb1ef031fd0622847070bbcf9da816502cc/multiprocess-0.70.18-py312-none-any.whl", hash = "sha256:9b78f8e5024b573730bfb654783a13800c2c0f2dfc0c25e70b40d184d64adaa2", size = 150287 }, - { url = "https://files.pythonhosted.org/packages/3b/c3/ca84c19bd14cdfc21c388fdcebf08b86a7a470ebc9f5c3c084fc2dbc50f7/multiprocess-0.70.18-py38-none-any.whl", hash = "sha256:dbf705e52a154fe5e90fb17b38f02556169557c2dd8bb084f2e06c2784d8279b", size = 132636 }, - { url = "https://files.pythonhosted.org/packages/6c/28/dd72947e59a6a8c856448a5e74da6201cb5502ddff644fbc790e4bd40b9a/multiprocess-0.70.18-py39-none-any.whl", hash = "sha256:e78ca805a72b1b810c690b6b4cc32579eba34f403094bbbae962b7b5bf9dfcb8", size = 133478 }, + { url = "https://files.pythonhosted.org/packages/93/13/df3505a46d0cd08428e4c8169a196131d1b0c4b515c3649829258843dde6/multidict-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3efe2c2cb5763f2f1b275ad2bf7a287d3f7ebbef35648a9726e3b69284a4f3d6", size = 48570 }, + { url = "https://files.pythonhosted.org/packages/f0/e1/a215908bfae1343cdb72f805366592bdd60487b4232d039c437fe8f5013d/multidict-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7053d3b0353a8b9de430a4f4b4268ac9a4fb3481af37dfe49825bf45ca24156", size = 29316 }, + { url = "https://files.pythonhosted.org/packages/70/0f/6dc70ddf5d442702ed74f298d69977f904960b82368532c88e854b79f72b/multidict-6.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27e5fc84ccef8dfaabb09d82b7d179c7cf1a3fbc8a966f8274fcb4ab2eb4cadb", size = 29640 }, + { url = "https://files.pythonhosted.org/packages/d8/6d/9c87b73a13d1cdea30b321ef4b3824449866bd7f7127eceed066ccb9b9ff/multidict-6.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e2b90b43e696f25c62656389d32236e049568b39320e2735d51f08fd362761b", size = 131067 }, + { url = "https://files.pythonhosted.org/packages/cc/1e/1b34154fef373371fd6c65125b3d42ff5f56c7ccc6bfff91b9b3c60ae9e0/multidict-6.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d83a047959d38a7ff552ff94be767b7fd79b831ad1cd9920662db05fec24fe72", size = 138507 }, + { url = "https://files.pythonhosted.org/packages/fb/e0/0bc6b2bac6e461822b5f575eae85da6aae76d0e2a79b6665d6206b8e2e48/multidict-6.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1a9dd711d0877a1ece3d2e4fea11a8e75741ca21954c919406b44e7cf971304", size = 133905 }, + { url = "https://files.pythonhosted.org/packages/ba/af/73d13b918071ff9b2205fcf773d316e0f8fefb4ec65354bbcf0b10908cc6/multidict-6.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2abea24d98246b94913b76a125e855eb5c434f7c46546046372fe60f666351", size = 129004 }, + { url = "https://files.pythonhosted.org/packages/74/21/23960627b00ed39643302d81bcda44c9444ebcdc04ee5bedd0757513f259/multidict-6.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4867cafcbc6585e4b678876c489b9273b13e9fff9f6d6d66add5e15d11d926cb", size = 121308 }, + { url = "https://files.pythonhosted.org/packages/8b/5c/cf282263ffce4a596ed0bb2aa1a1dddfe1996d6a62d08842a8d4b33dca13/multidict-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b48204e8d955c47c55b72779802b219a39acc3ee3d0116d5080c388970b76e3", size = 132608 }, + { url = "https://files.pythonhosted.org/packages/d7/3e/97e778c041c72063f42b290888daff008d3ab1427f5b09b714f5a8eff294/multidict-6.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d8fff389528cad1618fb4b26b95550327495462cd745d879a8c7c2115248e399", size = 127029 }, + { url = "https://files.pythonhosted.org/packages/47/ac/3efb7bfe2f3aefcf8d103e9a7162572f01936155ab2f7ebcc7c255a23212/multidict-6.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a7a9541cd308eed5e30318430a9c74d2132e9a8cb46b901326272d780bf2d423", size = 137594 }, + { url = "https://files.pythonhosted.org/packages/42/9b/6c6e9e8dc4f915fc90a9b7798c44a30773dea2995fdcb619870e705afe2b/multidict-6.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:da1758c76f50c39a2efd5e9859ce7d776317eb1dd34317c8152ac9251fc574a3", size = 134556 }, + { url = "https://files.pythonhosted.org/packages/1d/10/8e881743b26aaf718379a14ac58572a240e8293a1c9d68e1418fb11c0f90/multidict-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c943a53e9186688b45b323602298ab727d8865d8c9ee0b17f8d62d14b56f0753", size = 130993 }, + { url = "https://files.pythonhosted.org/packages/45/84/3eb91b4b557442802d058a7579e864b329968c8d0ea57d907e7023c677f2/multidict-6.1.0-cp311-cp311-win32.whl", hash = "sha256:90f8717cb649eea3504091e640a1b8568faad18bd4b9fcd692853a04475a4b80", size = 26405 }, + { url = "https://files.pythonhosted.org/packages/9f/0b/ad879847ecbf6d27e90a6eabb7eff6b62c129eefe617ea45eae7c1f0aead/multidict-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:82176036e65644a6cc5bd619f65f6f19781e8ec2e5330f51aa9ada7504cc1926", size = 28795 }, + { url = "https://files.pythonhosted.org/packages/fd/16/92057c74ba3b96d5e211b553895cd6dc7cc4d1e43d9ab8fafc727681ef71/multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa", size = 48713 }, + { url = "https://files.pythonhosted.org/packages/94/3d/37d1b8893ae79716179540b89fc6a0ee56b4a65fcc0d63535c6f5d96f217/multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436", size = 29516 }, + { url = "https://files.pythonhosted.org/packages/a2/12/adb6b3200c363062f805275b4c1e656be2b3681aada66c80129932ff0bae/multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761", size = 29557 }, + { url = "https://files.pythonhosted.org/packages/47/e9/604bb05e6e5bce1e6a5cf80a474e0f072e80d8ac105f1b994a53e0b28c42/multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e", size = 130170 }, + { url = "https://files.pythonhosted.org/packages/7e/13/9efa50801785eccbf7086b3c83b71a4fb501a4d43549c2f2f80b8787d69f/multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef", size = 134836 }, + { url = "https://files.pythonhosted.org/packages/bf/0f/93808b765192780d117814a6dfcc2e75de6dcc610009ad408b8814dca3ba/multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95", size = 133475 }, + { url = "https://files.pythonhosted.org/packages/d3/c8/529101d7176fe7dfe1d99604e48d69c5dfdcadb4f06561f465c8ef12b4df/multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925", size = 131049 }, + { url = "https://files.pythonhosted.org/packages/ca/0c/fc85b439014d5a58063e19c3a158a889deec399d47b5269a0f3b6a2e28bc/multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966", size = 120370 }, + { url = "https://files.pythonhosted.org/packages/db/46/d4416eb20176492d2258fbd47b4abe729ff3b6e9c829ea4236f93c865089/multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305", size = 125178 }, + { url = "https://files.pythonhosted.org/packages/5b/46/73697ad7ec521df7de5531a32780bbfd908ded0643cbe457f981a701457c/multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2", size = 119567 }, + { url = "https://files.pythonhosted.org/packages/cd/ed/51f060e2cb0e7635329fa6ff930aa5cffa17f4c7f5c6c3ddc3500708e2f2/multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2", size = 129822 }, + { url = "https://files.pythonhosted.org/packages/df/9e/ee7d1954b1331da3eddea0c4e08d9142da5f14b1321c7301f5014f49d492/multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6", size = 128656 }, + { url = "https://files.pythonhosted.org/packages/77/00/8538f11e3356b5d95fa4b024aa566cde7a38aa7a5f08f4912b32a037c5dc/multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3", size = 125360 }, + { url = "https://files.pythonhosted.org/packages/be/05/5d334c1f2462d43fec2363cd00b1c44c93a78c3925d952e9a71caf662e96/multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133", size = 26382 }, + { url = "https://files.pythonhosted.org/packages/a3/bf/f332a13486b1ed0496d624bcc7e8357bb8053823e8cd4b9a18edc1d97e73/multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1", size = 28529 }, + { url = "https://files.pythonhosted.org/packages/99/b7/b9e70fde2c0f0c9af4cc5277782a89b66d35948ea3369ec9f598358c3ac5/multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506", size = 10051 }, ] [[package]] @@ -2393,83 +1871,11 @@ wheels = [ [[package]] name = "narwhals" -version = "1.43.1" +version = "1.46.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/61/82/9f351a79260a6456db3f53d248268b4c3791f1e3228eec3c745e8816afd6/narwhals-1.43.1.tar.gz", hash = "sha256:6ff56d600da67a0a0980b83bd5577d076772fdba96474076ba4e76c920dbc1e5", size = 496655 } +sdist = { url = "https://files.pythonhosted.org/packages/06/7f/dd8c5f7978c3136de4d660877a5279e4688ad0c56dbc15ee003c2fe981cd/narwhals-1.46.0.tar.gz", hash = "sha256:fd7e53860b233c2b5566d8b4e1b3e8e9c01b5a87649a9f9a322742000f207a60", size = 512060 } wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/1e/b741d4eabbde95b1790e7df3c33c6b19f9b48db98a1416c6a6f06572bc66/narwhals-1.43.1-py3-none-any.whl", hash = "sha256:1ee508fa4dc0e05aa5b88717ba11613d8d9ccf0dd1e48513d4a3afb237dba9f2", size = 362737 }, -] - -[[package]] -name = "nbclient" -version = "0.10.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jupyter-client" }, - { name = "jupyter-core" }, - { name = "nbformat" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, -] - -[[package]] -name = "nbconvert" -version = "7.16.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "bleach", extra = ["css"] }, - { name = "defusedxml" }, - { name = "jinja2" }, - { name = "jupyter-core" }, - { name = "jupyterlab-pygments" }, - { name = "markupsafe" }, - { name = "mistune" }, - { name = "nbclient" }, - { name = "nbformat" }, - { name = "packaging" }, - { name = "pandocfilters" }, - { name = "pygments" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525 }, -] - -[[package]] -name = "nbformat" -version = "5.10.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "fastjsonschema" }, - { name = "jsonschema" }, - { name = "jupyter-core" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, -] - -[[package]] -name = "nbsphinx" -version = "0.9.7" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "docutils" }, - { name = "jinja2" }, - { name = "nbconvert" }, - { name = "nbformat" }, - { name = "sphinx" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1e/84/b1856b7651ac34e965aa567a158714c7f3bd42a1b1ce76bf423ffb99872c/nbsphinx-0.9.7.tar.gz", hash = "sha256:abd298a686d55fa894ef697c51d44f24e53aa312dadae38e82920f250a5456fe", size = 180479 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/49/2d/8c8e635bcc6757573d311bb3c5445426382f280da32b8cd6d82d501ef4a4/nbsphinx-0.9.7-py3-none-any.whl", hash = "sha256:7292c3767fea29e405c60743eee5393682a83982ab202ff98f5eb2db02629da8", size = 31660 }, + { url = "https://files.pythonhosted.org/packages/75/64/c46ba7517d90e330c4f35af1256d4b12ba037e2ef17d4aa4d4f11b4a143d/narwhals-1.46.0-py3-none-any.whl", hash = "sha256:f15d2255695d7e99f624f76aa5b765eb3fff8a509d3215049707af3a3feebc90", size = 373394 }, ] [[package]] @@ -2481,39 +1887,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, ] -[[package]] -name = "networkx" -version = "3.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406 }, -] - -[[package]] -name = "ninja" -version = "1.11.1.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/95/d4/6b0324541018561c5e73e617bd16f20a4fc17d1179bb3b3520b6ca8beb7b/ninja-1.11.1.4.tar.gz", hash = "sha256:6aa39f6e894e0452e5b297327db00019383ae55d5d9c57c73b04f13bf79d438a", size = 201256 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4f/b1/3a61b348936b62a386465b1937cd778fa3a5748582e26d832dbab844ff27/ninja-1.11.1.4-py3-none-macosx_10_9_universal2.whl", hash = "sha256:b33923c8da88e8da20b6053e38deb433f53656441614207e01d283ad02c5e8e7", size = 279071 }, - { url = "https://files.pythonhosted.org/packages/12/42/4c94fdad51fcf1f039a156e97de9e4d564c2a8cc0303782d36f9bd893a4b/ninja-1.11.1.4-py3-none-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cede0af00b58e27b31f2482ba83292a8e9171cdb9acc2c867a3b6e40b3353e43", size = 472026 }, - { url = "https://files.pythonhosted.org/packages/eb/7a/455d2877fe6cf99886849c7f9755d897df32eaf3a0fba47b56e615f880f7/ninja-1.11.1.4-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:096487995473320de7f65d622c3f1d16c3ad174797602218ca8c967f51ec38a0", size = 422814 }, - { url = "https://files.pythonhosted.org/packages/e3/ad/fb6cca942528e25e8e0ab0f0cf98fe007319bf05cf69d726c564b815c4af/ninja-1.11.1.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3090d4488fadf6047d0d7a1db0c9643a8d391f0d94729554dbb89b5bdc769d7", size = 156965 }, - { url = "https://files.pythonhosted.org/packages/a8/e7/d94a1b60031b115dd88526834b3da69eaacdc3c1a6769773ca8e2b1386b5/ninja-1.11.1.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ecce44a00325a93631792974659cf253a815cc6da4ec96f89742925dfc295a0d", size = 179937 }, - { url = "https://files.pythonhosted.org/packages/08/cc/e9316a28235409e9363794fc3d0b3083e48dd80d441006de66421e55f364/ninja-1.11.1.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c29bb66d2aa46a2409ab369ea804c730faec7652e8c22c1e428cc09216543e5", size = 157020 }, - { url = "https://files.pythonhosted.org/packages/e3/30/389b22300541aa5f2e9dad322c4de2f84be4e32aa4e8babd9160d620b5f1/ninja-1.11.1.4-py3-none-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:055f386fb550c2c9d6157e45e20a84d29c47968876b9c5794ae2aec46f952306", size = 130389 }, - { url = "https://files.pythonhosted.org/packages/a9/10/e27f35cb92813aabbb7ae771b1685b45be1cc8a0798ce7d4bfd08d142b93/ninja-1.11.1.4-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:f6186d7607bb090c3be1e10c8a56b690be238f953616626f5032238c66e56867", size = 372435 }, - { url = "https://files.pythonhosted.org/packages/c2/26/e3559619756739aae124c6abf7fe41f7e546ab1209cfbffb13137bff2d2e/ninja-1.11.1.4-py3-none-musllinux_1_1_i686.whl", hash = "sha256:cf4453679d15babc04ba023d68d091bb613091b67101c88f85d2171c6621c6eb", size = 419300 }, - { url = "https://files.pythonhosted.org/packages/35/46/809e4e9572570991b8e6f88f3583807d017371ab4cb09171cbc72a7eb3e4/ninja-1.11.1.4-py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:d4a6f159b08b0ac4aca5ee1572e3e402f969139e71d85d37c0e2872129098749", size = 420239 }, - { url = "https://files.pythonhosted.org/packages/e6/64/5cb5710d15f844edf02ada577f8eddfdcd116f47eec15850f3371a3a4b33/ninja-1.11.1.4-py3-none-musllinux_1_1_s390x.whl", hash = "sha256:c3b96bd875f3ef1db782470e9e41d7508905a0986571f219d20ffed238befa15", size = 415986 }, - { url = "https://files.pythonhosted.org/packages/95/b2/0e9ab1d926f423b12b09925f78afcc5e48b3c22e7121be3ddf6c35bf06a3/ninja-1.11.1.4-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:cf554e73f72c04deb04d0cf51f5fdb1903d9c9ca3d2344249c8ce3bd616ebc02", size = 379657 }, - { url = "https://files.pythonhosted.org/packages/c8/3e/fd6d330d0434168e7fe070d414b57dd99c4c133faa69c05b42a3cbdc6c13/ninja-1.11.1.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:cfdd09776436a1ff3c4a2558d3fc50a689fb9d7f1bdbc3e6f7b8c2991341ddb3", size = 454466 }, - { url = "https://files.pythonhosted.org/packages/e6/df/a25f3ad0b1c59d1b90564096e4fd89a6ca30d562b1e942f23880c3000b89/ninja-1.11.1.4-py3-none-win32.whl", hash = "sha256:2ab67a41c90bea5ec4b795bab084bc0b3b3bb69d3cd21ca0294fc0fc15a111eb", size = 255931 }, - { url = "https://files.pythonhosted.org/packages/5b/10/9b8fe9ac004847490cc7b54896124c01ce2d87d95dc60aabd0b8591addff/ninja-1.11.1.4-py3-none-win_amd64.whl", hash = "sha256:4617b3c12ff64b611a7d93fd9e378275512bb36eff8babff7c83f5116b4f8d66", size = 296461 }, - { url = "https://files.pythonhosted.org/packages/b9/58/612a17593c2d117f96c7f6b7f1e6570246bddc4b1e808519403a1417f217/ninja-1.11.1.4-py3-none-win_arm64.whl", hash = "sha256:5713cf50c5be50084a8693308a63ecf9e55c3132a78a41ab1363a28b6caaaee1", size = 271441 }, -] - [[package]] name = "nodeenv" version = "1.9.1" @@ -2523,182 +1896,63 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, ] +[[package]] +name = "numexpr" +version = "2.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/8f/2cc977e91adbfbcdb6b49fdb9147e1d1c7566eb2c0c1e737e9a47020b5ca/numexpr-2.11.0.tar.gz", hash = "sha256:75b2c01a4eda2e7c357bc67a3f5c3dd76506c15b5fd4dc42845ef2e182181bad", size = 108960 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/d1/1cf8137990b3f3d445556ed63b9bc347aec39bde8c41146b02d3b35c1adc/numexpr-2.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:450eba3c93c3e3e8070566ad8d70590949d6e574b1c960bf68edd789811e7da8", size = 147535 }, + { url = "https://files.pythonhosted.org/packages/b6/5e/bac7649d043f47c7c14c797efe60dbd19476468a149399cd706fe2e47f8c/numexpr-2.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f0eb88dbac8a7e61ee433006d0ddfd6eb921f5c6c224d1b50855bc98fb304c44", size = 136710 }, + { url = "https://files.pythonhosted.org/packages/1b/9f/c88fc34d82d23c66ea0b78b00a1fb3b64048e0f7ac7791b2cd0d2a4ce14d/numexpr-2.11.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a194e3684b3553ea199c3f4837f422a521c7e2f0cce13527adc3a6b4049f9e7c", size = 411169 }, + { url = "https://files.pythonhosted.org/packages/e4/8d/4d78dad430b41d836146f9e6f545f5c4f7d1972a6aa427d8570ab232bf16/numexpr-2.11.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f677668ab2bb2452fee955af3702fbb3b71919e61e4520762b1e5f54af59c0d8", size = 401671 }, + { url = "https://files.pythonhosted.org/packages/83/1c/414670eb41a82b78bd09769a4f5fb49a934f9b3990957f02c833637a511e/numexpr-2.11.0-cp311-cp311-win32.whl", hash = "sha256:7d9e76a77c9644fbd60da3984e516ead5b84817748c2da92515cd36f1941a04d", size = 153159 }, + { url = "https://files.pythonhosted.org/packages/0c/97/8d00ca9b36f3ac68a8fd85e930ab0c9448d8c9ca7ce195ee75c188dabd45/numexpr-2.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:7163b488bfdcd13c300a8407c309e4cee195ef95d07facf5ac2678d66c988805", size = 146224 }, + { url = "https://files.pythonhosted.org/packages/38/45/7a0e5a0b800d92e73825494ac695fa05a52c7fc7088d69a336880136b437/numexpr-2.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4229060be866813122385c608bbd3ea48fe0b33e91f2756810d28c1cdbfc98f1", size = 147494 }, + { url = "https://files.pythonhosted.org/packages/74/46/3a26b84e44f4739ec98de0ede4b95b4b8096f721e22d0e97517eeb02017e/numexpr-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:097aa8835d32d6ac52f2be543384019b4b134d1fb67998cbfc4271155edfe54a", size = 136832 }, + { url = "https://files.pythonhosted.org/packages/75/05/e3076ff25d4a108b47640c169c0a64811748c43b63d9cc052ea56de1631e/numexpr-2.11.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f082321c244ff5d0e252071fb2c4fe02063a45934144a1456a5370ca139bec2", size = 412618 }, + { url = "https://files.pythonhosted.org/packages/70/e8/15e0e077a004db0edd530da96c60c948689c888c464ee5d14b82405ebd86/numexpr-2.11.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7a19435ca3d7dd502b8d8dce643555eb1b6013989e3f7577857289f6db6be16", size = 403363 }, + { url = "https://files.pythonhosted.org/packages/10/14/f22afb3a7ae41d03ba87f62d00fbcfb76389f9cc91b7a82593c39c509318/numexpr-2.11.0-cp312-cp312-win32.whl", hash = "sha256:f326218262c8d8537887cc4bbd613c8409d62f2cac799835c0360e0d9cefaa5c", size = 153307 }, + { url = "https://files.pythonhosted.org/packages/18/70/abc585269424582b3cd6db261e33b2ec96b5d4971da3edb29fc9b62a8926/numexpr-2.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:0a184e5930c77ab91dd9beee4df403b825cd9dfc4e9ba4670d31c9fcb4e2c08e", size = 146337 }, +] + [[package]] name = "numpy" -version = "1.26.4" +version = "2.3.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129 } +sdist = { url = "https://files.pythonhosted.org/packages/2e/19/d7c972dfe90a353dbd3efbbe1d14a5951de80c99c9dc1b93cd998d51dc0f/numpy-2.3.1.tar.gz", hash = "sha256:1ec9ae20a4226da374362cca3c62cd753faf2f951440b0e3b98e93c235441d2b", size = 20390372 } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/57/baae43d14fe163fa0e4c47f307b6b2511ab8d7d30177c491960504252053/numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71", size = 20630554 }, - { url = "https://files.pythonhosted.org/packages/1a/2e/151484f49fd03944c4a3ad9c418ed193cfd02724e138ac8a9505d056c582/numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef", size = 13997127 }, - { url = "https://files.pythonhosted.org/packages/79/ae/7e5b85136806f9dadf4878bf73cf223fe5c2636818ba3ab1c585d0403164/numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e", size = 14222994 }, - { url = "https://files.pythonhosted.org/packages/3a/d0/edc009c27b406c4f9cbc79274d6e46d634d139075492ad055e3d68445925/numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5", size = 18252005 }, - { url = "https://files.pythonhosted.org/packages/09/bf/2b1aaf8f525f2923ff6cfcf134ae5e750e279ac65ebf386c75a0cf6da06a/numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a", size = 13885297 }, - { url = "https://files.pythonhosted.org/packages/df/a0/4e0f14d847cfc2a633a1c8621d00724f3206cfeddeb66d35698c4e2cf3d2/numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a", size = 18093567 }, - { url = "https://files.pythonhosted.org/packages/d2/b7/a734c733286e10a7f1a8ad1ae8c90f2d33bf604a96548e0a4a3a6739b468/numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20", size = 5968812 }, - { url = "https://files.pythonhosted.org/packages/3f/6b/5610004206cf7f8e7ad91c5a85a8c71b2f2f8051a0c0c4d5916b76d6cbb2/numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2", size = 15811913 }, - { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901 }, - { url = "https://files.pythonhosted.org/packages/75/5b/ca6c8bd14007e5ca171c7c03102d17b4f4e0ceb53957e8c44343a9546dcc/numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b", size = 13685868 }, - { url = "https://files.pythonhosted.org/packages/79/f8/97f10e6755e2a7d027ca783f63044d5b1bc1ae7acb12afe6a9b4286eac17/numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b", size = 13925109 }, - { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613 }, - { url = "https://files.pythonhosted.org/packages/4c/0c/9c603826b6465e82591e05ca230dfc13376da512b25ccd0894709b054ed0/numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a", size = 13572172 }, - { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643 }, - { url = "https://files.pythonhosted.org/packages/28/4a/46d9e65106879492374999e76eb85f87b15328e06bd1550668f79f7b18c6/numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110", size = 5677803 }, - { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754 }, -] - -[[package]] -name = "nvidia-cublas-cu12" -version = "12.6.4.1" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/eb/ff4b8c503fa1f1796679dce648854d58751982426e4e4b37d6fce49d259c/nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb", size = 393138322 }, - { url = "https://files.pythonhosted.org/packages/97/0d/f1f0cadbf69d5b9ef2e4f744c9466cb0a850741d08350736dfdb4aa89569/nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668", size = 390794615 }, -] - -[[package]] -name = "nvidia-cuda-cupti-cu12" -version = "12.6.80" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e6/8b/2f6230cb715646c3a9425636e513227ce5c93c4d65823a734f4bb86d43c3/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc", size = 8236764 }, - { url = "https://files.pythonhosted.org/packages/25/0f/acb326ac8fd26e13c799e0b4f3b2751543e1834f04d62e729485872198d4/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.whl", hash = "sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4", size = 8236756 }, - { url = "https://files.pythonhosted.org/packages/49/60/7b6497946d74bcf1de852a21824d63baad12cd417db4195fc1bfe59db953/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132", size = 8917980 }, - { url = "https://files.pythonhosted.org/packages/a5/24/120ee57b218d9952c379d1e026c4479c9ece9997a4fb46303611ee48f038/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73", size = 8917972 }, -] - -[[package]] -name = "nvidia-cuda-nvrtc-cu12" -version = "12.6.77" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/2f/72df534873235983cc0a5371c3661bebef7c4682760c275590b972c7b0f9/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13", size = 23162955 }, - { url = "https://files.pythonhosted.org/packages/75/2e/46030320b5a80661e88039f59060d1790298b4718944a65a7f2aeda3d9e9/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53", size = 23650380 }, -] - -[[package]] -name = "nvidia-cuda-runtime-cu12" -version = "12.6.77" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/ea/590b2ac00d772a8abd1c387a92b46486d2679ca6622fd25c18ff76265663/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd", size = 908052 }, - { url = "https://files.pythonhosted.org/packages/b7/3d/159023799677126e20c8fd580cca09eeb28d5c5a624adc7f793b9aa8bbfa/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e", size = 908040 }, - { url = "https://files.pythonhosted.org/packages/e1/23/e717c5ac26d26cf39a27fbc076240fad2e3b817e5889d671b67f4f9f49c5/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7", size = 897690 }, - { url = "https://files.pythonhosted.org/packages/f0/62/65c05e161eeddbafeca24dc461f47de550d9fa8a7e04eb213e32b55cfd99/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8", size = 897678 }, -] - -[[package]] -name = "nvidia-cudnn-cu12" -version = "9.5.1.17" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/99/93/a201a12d3ec1caa8c6ac34c1c2f9eeb696b886f0c36ff23c638b46603bd0/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def", size = 570523509 }, - { url = "https://files.pythonhosted.org/packages/2a/78/4535c9c7f859a64781e43c969a3a7e84c54634e319a996d43ef32ce46f83/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2", size = 570988386 }, -] - -[[package]] -name = "nvidia-cufft-cu12" -version = "11.3.0.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/1f/37/c50d2b2f2c07e146776389e3080f4faf70bcc4fa6e19d65bb54ca174ebc3/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6", size = 200164144 }, - { url = "https://files.pythonhosted.org/packages/ce/f5/188566814b7339e893f8d210d3a5332352b1409815908dad6a363dcceac1/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb", size = 200164135 }, - { url = "https://files.pythonhosted.org/packages/8f/16/73727675941ab8e6ffd86ca3a4b7b47065edcca7a997920b831f8147c99d/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5", size = 200221632 }, - { url = "https://files.pythonhosted.org/packages/60/de/99ec247a07ea40c969d904fc14f3a356b3e2a704121675b75c366b694ee1/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.whl", hash = "sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca", size = 200221622 }, -] - -[[package]] -name = "nvidia-cufile-cu12" -version = "1.11.1.6" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b2/66/cc9876340ac68ae71b15c743ddb13f8b30d5244af344ec8322b449e35426/nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159", size = 1142103 }, - { url = "https://files.pythonhosted.org/packages/17/bf/cc834147263b929229ce4aadd62869f0b195e98569d4c28b23edc72b85d9/nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db", size = 1066155 }, -] - -[[package]] -name = "nvidia-curand-cu12" -version = "10.3.7.77" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/42/ac/36543605358a355632f1a6faa3e2d5dfb91eab1e4bc7d552040e0383c335/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8", size = 56289881 }, - { url = "https://files.pythonhosted.org/packages/73/1b/44a01c4e70933637c93e6e1a8063d1e998b50213a6b65ac5a9169c47e98e/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf", size = 56279010 }, - { url = "https://files.pythonhosted.org/packages/4a/aa/2c7ff0b5ee02eaef890c0ce7d4f74bc30901871c5e45dee1ae6d0083cd80/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117", size = 56279000 }, - { url = "https://files.pythonhosted.org/packages/a6/02/5362a9396f23f7de1dd8a64369e87c85ffff8216fc8194ace0fa45ba27a5/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e", size = 56289882 }, -] - -[[package]] -name = "nvidia-cusolver-cu12" -version = "11.7.1.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, - { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/93/17/dbe1aa865e4fdc7b6d4d0dd308fdd5aaab60f939abfc0ea1954eac4fb113/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0", size = 157833628 }, - { url = "https://files.pythonhosted.org/packages/f0/6e/c2cf12c9ff8b872e92b4a5740701e51ff17689c4d726fca91875b07f655d/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c", size = 158229790 }, - { url = "https://files.pythonhosted.org/packages/9f/81/baba53585da791d043c10084cf9553e074548408e04ae884cfe9193bd484/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6", size = 158229780 }, - { url = "https://files.pythonhosted.org/packages/7c/5f/07d0ba3b7f19be5a5ec32a8679fc9384cfd9fc6c869825e93be9f28d6690/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e", size = 157833630 }, -] - -[[package]] -name = "nvidia-cusparse-cu12" -version = "12.5.4.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/eb/eb/6681efd0aa7df96b4f8067b3ce7246833dd36830bb4cec8896182773db7d/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887", size = 216451147 }, - { url = "https://files.pythonhosted.org/packages/d3/56/3af21e43014eb40134dea004e8d0f1ef19d9596a39e4d497d5a7de01669f/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1", size = 216451135 }, - { url = "https://files.pythonhosted.org/packages/06/1e/b8b7c2f4099a37b96af5c9bb158632ea9e5d9d27d7391d7eb8fc45236674/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73", size = 216561367 }, - { url = "https://files.pythonhosted.org/packages/43/ac/64c4316ba163e8217a99680c7605f779accffc6a4bcd0c778c12948d3707/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f", size = 216561357 }, -] - -[[package]] -name = "nvidia-cusparselt-cu12" -version = "0.6.3" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/62/da/4de092c61c6dea1fc9c936e69308a02531d122e12f1f649825934ad651b5/nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1", size = 156402859 }, - { url = "https://files.pythonhosted.org/packages/3b/9a/72ef35b399b0e183bc2e8f6f558036922d453c4d8237dab26c666a04244b/nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46", size = 156785796 }, -] - -[[package]] -name = "nvidia-nccl-cu12" -version = "2.26.2" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/69/5b/ca2f213f637305633814ae8c36b153220e40a07ea001966dcd87391f3acb/nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522", size = 291671495 }, - { url = "https://files.pythonhosted.org/packages/67/ca/f42388aed0fddd64ade7493dbba36e1f534d4e6fdbdd355c6a90030ae028/nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6", size = 201319755 }, -] - -[[package]] -name = "nvidia-nvjitlink-cu12" -version = "12.6.85" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/d7/c5383e47c7e9bf1c99d5bd2a8c935af2b6d705ad831a7ec5c97db4d82f4f/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a", size = 19744971 }, - { url = "https://files.pythonhosted.org/packages/31/db/dc71113d441f208cdfe7ae10d4983884e13f464a6252450693365e166dcf/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41", size = 19270338 }, -] - -[[package]] -name = "nvidia-nvtx-cu12" -version = "12.6.77" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/93/80f8a520375af9d7ee44571a6544653a176e53c2b8ccce85b97b83c2491b/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b", size = 90549 }, - { url = "https://files.pythonhosted.org/packages/2b/53/36e2fd6c7068997169b49ffc8c12d5af5e5ff209df6e1a2c4d373b3a638f/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059", size = 90539 }, - { url = "https://files.pythonhosted.org/packages/56/9a/fff8376f8e3d084cd1530e1ef7b879bb7d6d265620c95c1b322725c694f4/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2", size = 89276 }, - { url = "https://files.pythonhosted.org/packages/9e/4e/0d0c945463719429b7bd21dece907ad0bde437a2ff12b9b12fee94722ab0/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1", size = 89265 }, + { url = "https://files.pythonhosted.org/packages/b0/c7/87c64d7ab426156530676000c94784ef55676df2f13b2796f97722464124/numpy-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6ea9e48336a402551f52cd8f593343699003d2353daa4b72ce8d34f66b722070", size = 21199346 }, + { url = "https://files.pythonhosted.org/packages/58/0e/0966c2f44beeac12af8d836e5b5f826a407cf34c45cb73ddcdfce9f5960b/numpy-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ccb7336eaf0e77c1635b232c141846493a588ec9ea777a7c24d7166bb8533ae", size = 14361143 }, + { url = "https://files.pythonhosted.org/packages/7d/31/6e35a247acb1bfc19226791dfc7d4c30002cd4e620e11e58b0ddf836fe52/numpy-2.3.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0bb3a4a61e1d327e035275d2a993c96fa786e4913aa089843e6a2d9dd205c66a", size = 5378989 }, + { url = "https://files.pythonhosted.org/packages/b0/25/93b621219bb6f5a2d4e713a824522c69ab1f06a57cd571cda70e2e31af44/numpy-2.3.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:e344eb79dab01f1e838ebb67aab09965fb271d6da6b00adda26328ac27d4a66e", size = 6912890 }, + { url = "https://files.pythonhosted.org/packages/ef/60/6b06ed98d11fb32e27fb59468b42383f3877146d3ee639f733776b6ac596/numpy-2.3.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:467db865b392168ceb1ef1ffa6f5a86e62468c43e0cfb4ab6da667ede10e58db", size = 14569032 }, + { url = "https://files.pythonhosted.org/packages/75/c9/9bec03675192077467a9c7c2bdd1f2e922bd01d3a69b15c3a0fdcd8548f6/numpy-2.3.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:afed2ce4a84f6b0fc6c1ce734ff368cbf5a5e24e8954a338f3bdffa0718adffb", size = 16930354 }, + { url = "https://files.pythonhosted.org/packages/6a/e2/5756a00cabcf50a3f527a0c968b2b4881c62b1379223931853114fa04cda/numpy-2.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0025048b3c1557a20bc80d06fdeb8cc7fc193721484cca82b2cfa072fec71a93", size = 15879605 }, + { url = "https://files.pythonhosted.org/packages/ff/86/a471f65f0a86f1ca62dcc90b9fa46174dd48f50214e5446bc16a775646c5/numpy-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5ee121b60aa509679b682819c602579e1df14a5b07fe95671c8849aad8f2115", size = 18666994 }, + { url = "https://files.pythonhosted.org/packages/43/a6/482a53e469b32be6500aaf61cfafd1de7a0b0d484babf679209c3298852e/numpy-2.3.1-cp311-cp311-win32.whl", hash = "sha256:a8b740f5579ae4585831b3cf0e3b0425c667274f82a484866d2adf9570539369", size = 6603672 }, + { url = "https://files.pythonhosted.org/packages/6b/fb/bb613f4122c310a13ec67585c70e14b03bfc7ebabd24f4d5138b97371d7c/numpy-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4580adadc53311b163444f877e0789f1c8861e2698f6b2a4ca852fda154f3ff", size = 13024015 }, + { url = "https://files.pythonhosted.org/packages/51/58/2d842825af9a0c041aca246dc92eb725e1bc5e1c9ac89712625db0c4e11c/numpy-2.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:ec0bdafa906f95adc9a0c6f26a4871fa753f25caaa0e032578a30457bff0af6a", size = 10456989 }, + { url = "https://files.pythonhosted.org/packages/c6/56/71ad5022e2f63cfe0ca93559403d0edef14aea70a841d640bd13cdba578e/numpy-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2959d8f268f3d8ee402b04a9ec4bb7604555aeacf78b360dc4ec27f1d508177d", size = 20896664 }, + { url = "https://files.pythonhosted.org/packages/25/65/2db52ba049813670f7f987cc5db6dac9be7cd95e923cc6832b3d32d87cef/numpy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:762e0c0c6b56bdedfef9a8e1d4538556438288c4276901ea008ae44091954e29", size = 14131078 }, + { url = "https://files.pythonhosted.org/packages/57/dd/28fa3c17b0e751047ac928c1e1b6990238faad76e9b147e585b573d9d1bd/numpy-2.3.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:867ef172a0976aaa1f1d1b63cf2090de8b636a7674607d514505fb7276ab08fc", size = 5112554 }, + { url = "https://files.pythonhosted.org/packages/c9/fc/84ea0cba8e760c4644b708b6819d91784c290288c27aca916115e3311d17/numpy-2.3.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:4e602e1b8682c2b833af89ba641ad4176053aaa50f5cacda1a27004352dde943", size = 6646560 }, + { url = "https://files.pythonhosted.org/packages/61/b2/512b0c2ddec985ad1e496b0bd853eeb572315c0f07cd6997473ced8f15e2/numpy-2.3.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8e333040d069eba1652fb08962ec5b76af7f2c7bce1df7e1418c8055cf776f25", size = 14260638 }, + { url = "https://files.pythonhosted.org/packages/6e/45/c51cb248e679a6c6ab14b7a8e3ead3f4a3fe7425fc7a6f98b3f147bec532/numpy-2.3.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e7cbf5a5eafd8d230a3ce356d892512185230e4781a361229bd902ff403bc660", size = 16632729 }, + { url = "https://files.pythonhosted.org/packages/e4/ff/feb4be2e5c09a3da161b412019caf47183099cbea1132fd98061808c2df2/numpy-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f1b8f26d1086835f442286c1d9b64bb3974b0b1e41bb105358fd07d20872952", size = 15565330 }, + { url = "https://files.pythonhosted.org/packages/bc/6d/ceafe87587101e9ab0d370e4f6e5f3f3a85b9a697f2318738e5e7e176ce3/numpy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ee8340cb48c9b7a5899d1149eece41ca535513a9698098edbade2a8e7a84da77", size = 18361734 }, + { url = "https://files.pythonhosted.org/packages/2b/19/0fb49a3ea088be691f040c9bf1817e4669a339d6e98579f91859b902c636/numpy-2.3.1-cp312-cp312-win32.whl", hash = "sha256:e772dda20a6002ef7061713dc1e2585bc1b534e7909b2030b5a46dae8ff077ab", size = 6320411 }, + { url = "https://files.pythonhosted.org/packages/b1/3e/e28f4c1dd9e042eb57a3eb652f200225e311b608632bc727ae378623d4f8/numpy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cfecc7822543abdea6de08758091da655ea2210b8ffa1faf116b940693d3df76", size = 12734973 }, + { url = "https://files.pythonhosted.org/packages/04/a8/8a5e9079dc722acf53522b8f8842e79541ea81835e9b5483388701421073/numpy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:7be91b2239af2658653c5bb6f1b8bccafaf08226a258caf78ce44710a0160d30", size = 10191491 }, + { url = "https://files.pythonhosted.org/packages/e8/34/facc13b9b42ddca30498fc51f7f73c3d0f2be179943a4b4da8686e259740/numpy-2.3.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ad506d4b09e684394c42c966ec1527f6ebc25da7f4da4b1b056606ffe446b8a3", size = 21070637 }, + { url = "https://files.pythonhosted.org/packages/65/b6/41b705d9dbae04649b529fc9bd3387664c3281c7cd78b404a4efe73dcc45/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ebb8603d45bc86bbd5edb0d63e52c5fd9e7945d3a503b77e486bd88dde67a19b", size = 5304087 }, + { url = "https://files.pythonhosted.org/packages/7a/b4/fe3ac1902bff7a4934a22d49e1c9d71a623204d654d4cc43c6e8fe337fcb/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:15aa4c392ac396e2ad3d0a2680c0f0dee420f9fed14eef09bdb9450ee6dcb7b7", size = 6817588 }, + { url = "https://files.pythonhosted.org/packages/ae/ee/89bedf69c36ace1ac8f59e97811c1f5031e179a37e4821c3a230bf750142/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c6e0bf9d1a2f50d2b65a7cf56db37c095af17b59f6c132396f7c6d5dd76484df", size = 14399010 }, + { url = "https://files.pythonhosted.org/packages/15/08/e00e7070ede29b2b176165eba18d6f9784d5349be3c0c1218338e79c27fd/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eabd7e8740d494ce2b4ea0ff05afa1b7b291e978c0ae075487c51e8bd93c0c68", size = 16752042 }, + { url = "https://files.pythonhosted.org/packages/48/6b/1c6b515a83d5564b1698a61efa245727c8feecf308f4091f565988519d20/numpy-2.3.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e610832418a2bc09d974cc9fecebfa51e9532d6190223bc5ef6a7402ebf3b5cb", size = 12927246 }, ] [[package]] @@ -2716,12 +1970,13 @@ wheels = [ [[package]] name = "open-notebook" -version = "0.2.3" +version = "0.3.0" source = { editable = "." } dependencies = [ { name = "ai-prompter" }, { name = "content-core" }, { name = "esperanto" }, + { name = "fastapi" }, { name = "groq" }, { name = "httpx", extra = ["socks"] }, { name = "humanize" }, @@ -2739,16 +1994,18 @@ dependencies = [ { name = "langgraph-checkpoint-sqlite" }, { name = "loguru" }, { name = "nest-asyncio" }, - { name = "podcastfy" }, + { name = "podcast-creator" }, { name = "pydantic" }, { name = "python-dotenv" }, - { name = "sdblpy" }, { name = "streamlit" }, { name = "streamlit-monaco" }, { name = "streamlit-scrollable-textbox" }, { name = "streamlit-tags" }, + { name = "surreal-commands" }, + { name = "surrealdb" }, { name = "tiktoken" }, { name = "tomli" }, + { name = "uvicorn" }, ] [package.optional-dependencies] @@ -2772,6 +2029,7 @@ requires-dist = [ { name = "ai-prompter", specifier = ">=0.3" }, { name = "content-core", specifier = ">=1.0.2" }, { name = "esperanto", specifier = ">=2.0.4" }, + { name = "fastapi", specifier = ">=0.104.0" }, { name = "groq", specifier = ">=0.12.0" }, { name = "httpx", extras = ["socks"], specifier = ">=0.27.0" }, { name = "humanize", specifier = ">=4.11.0" }, @@ -2792,19 +2050,21 @@ requires-dist = [ { name = "loguru", specifier = ">=0.7.2" }, { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.11.1" }, { name = "nest-asyncio", specifier = ">=1.6.0" }, - { name = "podcastfy", git = "https://github.com/lfnovo/podcastfy" }, + { name = "podcast-creator", specifier = ">=0.2.6" }, { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=4.0.1" }, { name = "pydantic", specifier = ">=2.9.2" }, { name = "python-dotenv", specifier = ">=1.0.1" }, { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.5.5" }, - { name = "sdblpy", git = "https://github.com/lfnovo/surreal-lite-py" }, { name = "streamlit", specifier = ">=1.45.0" }, { name = "streamlit-monaco", specifier = ">=0.1.3" }, { name = "streamlit-scrollable-textbox", specifier = ">=0.0.3" }, { name = "streamlit-tags", specifier = ">=1.2.8" }, + { name = "surreal-commands", specifier = ">=1.0.13" }, + { name = "surrealdb", specifier = ">=1.0.4" }, { name = "tiktoken", specifier = ">=0.8.0" }, { name = "tomli", specifier = ">=2.0.2" }, { name = "types-requests", marker = "extra == 'dev'", specifier = ">=2.32.0.20241016" }, + { name = "uvicorn", specifier = ">=0.24.0" }, ] [package.metadata.requires-dev] @@ -2815,7 +2075,7 @@ dev = [ [[package]] name = "openai" -version = "1.88.0" +version = "1.95.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -2827,26 +2087,9 @@ dependencies = [ { name = "tqdm" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5a/ea/bbeef604d1fe0f7e9111745bb8a81362973a95713b28855beb9a9832ab12/openai-1.88.0.tar.gz", hash = "sha256:122d35e42998255cf1fc84560f6ee49a844e65c054cd05d3e42fda506b832bb1", size = 470963 } +sdist = { url = "https://files.pythonhosted.org/packages/a1/a3/70cd57c7d71086c532ce90de5fdef4165dc6ae9dbf346da6737ff9ebafaa/openai-1.95.1.tar.gz", hash = "sha256:f089b605282e2a2b6776090b4b46563ac1da77f56402a222597d591e2dcc1086", size = 488271 } wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/03/ef68d77a38dd383cbed7fc898857d394d5a8b0520a35f054e7fe05dc3ac1/openai-1.88.0-py3-none-any.whl", hash = "sha256:7edd7826b3b83f5846562a6f310f040c79576278bf8e3687b30ba05bb5dff978", size = 734293 }, -] - -[[package]] -name = "opencv-python-headless" -version = "4.11.0.86" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/36/2f/5b2b3ba52c864848885ba988f24b7f105052f68da9ab0e693cc7c25b0b30/opencv-python-headless-4.11.0.86.tar.gz", hash = "sha256:996eb282ca4b43ec6a3972414de0e2331f5d9cda2b41091a49739c19fb843798", size = 95177929 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/dc/53/2c50afa0b1e05ecdb4603818e85f7d174e683d874ef63a6abe3ac92220c8/opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:48128188ade4a7e517237c8e1e11a9cdf5c282761473383e77beb875bb1e61ca", size = 37326460 }, - { url = "https://files.pythonhosted.org/packages/3b/43/68555327df94bb9b59a1fd645f63fafb0762515344d2046698762fc19d58/opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:a66c1b286a9de872c343ee7c3553b084244299714ebb50fbdcd76f07ebbe6c81", size = 56723330 }, - { url = "https://files.pythonhosted.org/packages/45/be/1438ce43ebe65317344a87e4b150865c5585f4c0db880a34cdae5ac46881/opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6efabcaa9df731f29e5ea9051776715b1bdd1845d7c9530065c7951d2a2899eb", size = 29487060 }, - { url = "https://files.pythonhosted.org/packages/dd/5c/c139a7876099916879609372bfa513b7f1257f7f1a908b0bdc1c2328241b/opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e0a27c19dd1f40ddff94976cfe43066fbbe9dfbb2ec1907d66c19caef42a57b", size = 49969856 }, - { url = "https://files.pythonhosted.org/packages/95/dd/ed1191c9dc91abcc9f752b499b7928aacabf10567bb2c2535944d848af18/opencv_python_headless-4.11.0.86-cp37-abi3-win32.whl", hash = "sha256:f447d8acbb0b6f2808da71fddd29c1cdd448d2bc98f72d9bb78a7a898fc9621b", size = 29324425 }, - { url = "https://files.pythonhosted.org/packages/86/8a/69176a64335aed183529207ba8bc3d329c2999d852b4f3818027203f50e6/opencv_python_headless-4.11.0.86-cp37-abi3-win_amd64.whl", hash = "sha256:6c304df9caa7a6a5710b91709dd4786bf20a74d57672b3c31f7033cc638174ca", size = 39402386 }, + { url = "https://files.pythonhosted.org/packages/02/1d/0432ea635097f4dbb34641a3650803d8a4aa29d06bafc66583bf1adcceb4/openai-1.95.1-py3-none-any.whl", hash = "sha256:8bbdfeceef231b1ddfabbc232b179d79f8b849aab5a7da131178f8d10e0f162f", size = 755613 }, ] [[package]] @@ -2934,7 +2177,7 @@ wheels = [ [[package]] name = "pandas" -version = "2.3.0" +version = "2.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "numpy" }, @@ -2942,41 +2185,22 @@ dependencies = [ { name = "pytz" }, { name = "tzdata" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/72/51/48f713c4c728d7c55ef7444ba5ea027c26998d96d1a40953b346438602fc/pandas-2.3.0.tar.gz", hash = "sha256:34600ab34ebf1131a7613a260a61dbe8b62c188ec0ea4c296da7c9a06b004133", size = 4484490 } +sdist = { url = "https://files.pythonhosted.org/packages/d1/6f/75aa71f8a14267117adeeed5d21b204770189c0a0025acbdc03c337b28fc/pandas-2.3.1.tar.gz", hash = "sha256:0a95b9ac964fe83ce317827f80304d37388ea77616b1425f0ae41c9d2d0d7bb2", size = 4487493 } wheels = [ - { url = "https://files.pythonhosted.org/packages/96/1e/ba313812a699fe37bf62e6194265a4621be11833f5fce46d9eae22acb5d7/pandas-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8adff9f138fc614347ff33812046787f7d43b3cef7c0f0171b3340cae333f6ca", size = 11551836 }, - { url = "https://files.pythonhosted.org/packages/1b/cc/0af9c07f8d714ea563b12383a7e5bde9479cf32413ee2f346a9c5a801f22/pandas-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e5f08eb9a445d07720776df6e641975665c9ea12c9d8a331e0f6890f2dcd76ef", size = 10807977 }, - { url = "https://files.pythonhosted.org/packages/ee/3e/8c0fb7e2cf4a55198466ced1ca6a9054ae3b7e7630df7757031df10001fd/pandas-2.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa35c266c8cd1a67d75971a1912b185b492d257092bdd2709bbdebe574ed228d", size = 11788230 }, - { url = "https://files.pythonhosted.org/packages/14/22/b493ec614582307faf3f94989be0f7f0a71932ed6f56c9a80c0bb4a3b51e/pandas-2.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14a0cc77b0f089d2d2ffe3007db58f170dae9b9f54e569b299db871a3ab5bf46", size = 12370423 }, - { url = "https://files.pythonhosted.org/packages/9f/74/b012addb34cda5ce855218a37b258c4e056a0b9b334d116e518d72638737/pandas-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c06f6f144ad0a1bf84699aeea7eff6068ca5c63ceb404798198af7eb86082e33", size = 12990594 }, - { url = "https://files.pythonhosted.org/packages/95/81/b310e60d033ab64b08e66c635b94076488f0b6ce6a674379dd5b224fc51c/pandas-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ed16339bc354a73e0a609df36d256672c7d296f3f767ac07257801aa064ff73c", size = 13745952 }, - { url = "https://files.pythonhosted.org/packages/25/ac/f6ee5250a8881b55bd3aecde9b8cfddea2f2b43e3588bca68a4e9aaf46c8/pandas-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:fa07e138b3f6c04addfeaf56cc7fdb96c3b68a3fe5e5401251f231fce40a0d7a", size = 11094534 }, - { url = "https://files.pythonhosted.org/packages/94/46/24192607058dd607dbfacdd060a2370f6afb19c2ccb617406469b9aeb8e7/pandas-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2eb4728a18dcd2908c7fccf74a982e241b467d178724545a48d0caf534b38ebf", size = 11573865 }, - { url = "https://files.pythonhosted.org/packages/9f/cc/ae8ea3b800757a70c9fdccc68b67dc0280a6e814efcf74e4211fd5dea1ca/pandas-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9d8c3187be7479ea5c3d30c32a5d73d62a621166675063b2edd21bc47614027", size = 10702154 }, - { url = "https://files.pythonhosted.org/packages/d8/ba/a7883d7aab3d24c6540a2768f679e7414582cc389876d469b40ec749d78b/pandas-2.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ff730713d4c4f2f1c860e36c005c7cefc1c7c80c21c0688fd605aa43c9fcf09", size = 11262180 }, - { url = "https://files.pythonhosted.org/packages/01/a5/931fc3ad333d9d87b10107d948d757d67ebcfc33b1988d5faccc39c6845c/pandas-2.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba24af48643b12ffe49b27065d3babd52702d95ab70f50e1b34f71ca703e2c0d", size = 11991493 }, - { url = "https://files.pythonhosted.org/packages/d7/bf/0213986830a92d44d55153c1d69b509431a972eb73f204242988c4e66e86/pandas-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:404d681c698e3c8a40a61d0cd9412cc7364ab9a9cc6e144ae2992e11a2e77a20", size = 12470733 }, - { url = "https://files.pythonhosted.org/packages/a4/0e/21eb48a3a34a7d4bac982afc2c4eb5ab09f2d988bdf29d92ba9ae8e90a79/pandas-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6021910b086b3ca756755e86ddc64e0ddafd5e58e076c72cb1585162e5ad259b", size = 13212406 }, - { url = "https://files.pythonhosted.org/packages/1f/d9/74017c4eec7a28892d8d6e31ae9de3baef71f5a5286e74e6b7aad7f8c837/pandas-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:094e271a15b579650ebf4c5155c05dcd2a14fd4fdd72cf4854b2f7ad31ea30be", size = 10976199 }, -] - -[[package]] -name = "pandoc" -version = "2.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "plumbum" }, - { name = "ply" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/10/9a/e3186e760c57ee5f1c27ea5cea577a0ff9abfca51eefcb4d9a4cd39aff2e/pandoc-2.4.tar.gz", hash = "sha256:ecd1f8cbb7f4180c6b5db4a17a7c1a74df519995f5f186ef81ce72a9cbd0dd9a", size = 34635 } - -[[package]] -name = "pandocfilters" -version = "1.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, + { url = "https://files.pythonhosted.org/packages/76/1c/ccf70029e927e473a4476c00e0d5b32e623bff27f0402d0a92b7fc29bb9f/pandas-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2b0540963d83431f5ce8870ea02a7430adca100cec8a050f0811f8e31035541b", size = 11566608 }, + { url = "https://files.pythonhosted.org/packages/ec/d3/3c37cb724d76a841f14b8f5fe57e5e3645207cc67370e4f84717e8bb7657/pandas-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fe7317f578c6a153912bd2292f02e40c1d8f253e93c599e82620c7f69755c74f", size = 10823181 }, + { url = "https://files.pythonhosted.org/packages/8a/4c/367c98854a1251940edf54a4df0826dcacfb987f9068abf3e3064081a382/pandas-2.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e6723a27ad7b244c0c79d8e7007092d7c8f0f11305770e2f4cd778b3ad5f9f85", size = 11793570 }, + { url = "https://files.pythonhosted.org/packages/07/5f/63760ff107bcf5146eee41b38b3985f9055e710a72fdd637b791dea3495c/pandas-2.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3462c3735fe19f2638f2c3a40bd94ec2dc5ba13abbb032dd2fa1f540a075509d", size = 12378887 }, + { url = "https://files.pythonhosted.org/packages/15/53/f31a9b4dfe73fe4711c3a609bd8e60238022f48eacedc257cd13ae9327a7/pandas-2.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:98bcc8b5bf7afed22cc753a28bc4d9e26e078e777066bc53fac7904ddef9a678", size = 13230957 }, + { url = "https://files.pythonhosted.org/packages/e0/94/6fce6bf85b5056d065e0a7933cba2616dcb48596f7ba3c6341ec4bcc529d/pandas-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4d544806b485ddf29e52d75b1f559142514e60ef58a832f74fb38e48d757b299", size = 13883883 }, + { url = "https://files.pythonhosted.org/packages/c8/7b/bdcb1ed8fccb63d04bdb7635161d0ec26596d92c9d7a6cce964e7876b6c1/pandas-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b3cd4273d3cb3707b6fffd217204c52ed92859533e31dc03b7c5008aa933aaab", size = 11340212 }, + { url = "https://files.pythonhosted.org/packages/46/de/b8445e0f5d217a99fe0eeb2f4988070908979bec3587c0633e5428ab596c/pandas-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:689968e841136f9e542020698ee1c4fbe9caa2ed2213ae2388dc7b81721510d3", size = 11588172 }, + { url = "https://files.pythonhosted.org/packages/1e/e0/801cdb3564e65a5ac041ab99ea6f1d802a6c325bb6e58c79c06a3f1cd010/pandas-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:025e92411c16cbe5bb2a4abc99732a6b132f439b8aab23a59fa593eb00704232", size = 10717365 }, + { url = "https://files.pythonhosted.org/packages/51/a5/c76a8311833c24ae61a376dbf360eb1b1c9247a5d9c1e8b356563b31b80c/pandas-2.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b7ff55f31c4fcb3e316e8f7fa194566b286d6ac430afec0d461163312c5841e", size = 11280411 }, + { url = "https://files.pythonhosted.org/packages/da/01/e383018feba0a1ead6cf5fe8728e5d767fee02f06a3d800e82c489e5daaf/pandas-2.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7dcb79bf373a47d2a40cf7232928eb7540155abbc460925c2c96d2d30b006eb4", size = 11988013 }, + { url = "https://files.pythonhosted.org/packages/5b/14/cec7760d7c9507f11c97d64f29022e12a6cc4fc03ac694535e89f88ad2ec/pandas-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:56a342b231e8862c96bdb6ab97170e203ce511f4d0429589c8ede1ee8ece48b8", size = 12767210 }, + { url = "https://files.pythonhosted.org/packages/50/b9/6e2d2c6728ed29fb3d4d4d302504fb66f1a543e37eb2e43f352a86365cdf/pandas-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ca7ed14832bce68baef331f4d7f294411bed8efd032f8109d690df45e00c4679", size = 13440571 }, + { url = "https://files.pythonhosted.org/packages/80/a5/3a92893e7399a691bad7664d977cb5e7c81cf666c81f89ea76ba2bff483d/pandas-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:ac942bfd0aca577bef61f2bc8da8147c4ef6879965ef883d8e8d5d2dc3e744b8", size = 10987601 }, ] [[package]] @@ -3011,39 +2235,39 @@ wheels = [ [[package]] name = "pillow" -version = "11.2.1" +version = "11.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/af/cb/bb5c01fcd2a69335b86c22142b2bccfc3464087efb7fd382eee5ffc7fdf7/pillow-11.2.1.tar.gz", hash = "sha256:a64dd61998416367b7ef979b73d3a85853ba9bec4c2925f74e588879a58716b6", size = 47026707 } +sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069 } wheels = [ - { url = "https://files.pythonhosted.org/packages/68/08/3fbf4b98924c73037a8e8b4c2c774784805e0fb4ebca6c5bb60795c40125/pillow-11.2.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:35ca289f712ccfc699508c4658a1d14652e8033e9b69839edf83cbdd0ba39e70", size = 3198450 }, - { url = "https://files.pythonhosted.org/packages/84/92/6505b1af3d2849d5e714fc75ba9e69b7255c05ee42383a35a4d58f576b16/pillow-11.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0409af9f829f87a2dfb7e259f78f317a5351f2045158be321fd135973fff7bf", size = 3030550 }, - { url = "https://files.pythonhosted.org/packages/3c/8c/ac2f99d2a70ff966bc7eb13dacacfaab57c0549b2ffb351b6537c7840b12/pillow-11.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4e5c5edee874dce4f653dbe59db7c73a600119fbea8d31f53423586ee2aafd7", size = 4415018 }, - { url = "https://files.pythonhosted.org/packages/1f/e3/0a58b5d838687f40891fff9cbaf8669f90c96b64dc8f91f87894413856c6/pillow-11.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b93a07e76d13bff9444f1a029e0af2964e654bfc2e2c2d46bfd080df5ad5f3d8", size = 4498006 }, - { url = "https://files.pythonhosted.org/packages/21/f5/6ba14718135f08fbfa33308efe027dd02b781d3f1d5c471444a395933aac/pillow-11.2.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:e6def7eed9e7fa90fde255afaf08060dc4b343bbe524a8f69bdd2a2f0018f600", size = 4517773 }, - { url = "https://files.pythonhosted.org/packages/20/f2/805ad600fc59ebe4f1ba6129cd3a75fb0da126975c8579b8f57abeb61e80/pillow-11.2.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8f4f3724c068be008c08257207210c138d5f3731af6c155a81c2b09a9eb3a788", size = 4607069 }, - { url = "https://files.pythonhosted.org/packages/71/6b/4ef8a288b4bb2e0180cba13ca0a519fa27aa982875882392b65131401099/pillow-11.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a0a6709b47019dff32e678bc12c63008311b82b9327613f534e496dacaefb71e", size = 4583460 }, - { url = "https://files.pythonhosted.org/packages/62/ae/f29c705a09cbc9e2a456590816e5c234382ae5d32584f451c3eb41a62062/pillow-11.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f6b0c664ccb879109ee3ca702a9272d877f4fcd21e5eb63c26422fd6e415365e", size = 4661304 }, - { url = "https://files.pythonhosted.org/packages/6e/1a/c8217b6f2f73794a5e219fbad087701f412337ae6dbb956db37d69a9bc43/pillow-11.2.1-cp311-cp311-win32.whl", hash = "sha256:cc5d875d56e49f112b6def6813c4e3d3036d269c008bf8aef72cd08d20ca6df6", size = 2331809 }, - { url = "https://files.pythonhosted.org/packages/e2/72/25a8f40170dc262e86e90f37cb72cb3de5e307f75bf4b02535a61afcd519/pillow-11.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:0f5c7eda47bf8e3c8a283762cab94e496ba977a420868cb819159980b6709193", size = 2676338 }, - { url = "https://files.pythonhosted.org/packages/06/9e/76825e39efee61efea258b479391ca77d64dbd9e5804e4ad0fa453b4ba55/pillow-11.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:4d375eb838755f2528ac8cbc926c3e31cc49ca4ad0cf79cff48b20e30634a4a7", size = 2414918 }, - { url = "https://files.pythonhosted.org/packages/c7/40/052610b15a1b8961f52537cc8326ca6a881408bc2bdad0d852edeb6ed33b/pillow-11.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:78afba22027b4accef10dbd5eed84425930ba41b3ea0a86fa8d20baaf19d807f", size = 3190185 }, - { url = "https://files.pythonhosted.org/packages/e5/7e/b86dbd35a5f938632093dc40d1682874c33dcfe832558fc80ca56bfcb774/pillow-11.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78092232a4ab376a35d68c4e6d5e00dfd73454bd12b230420025fbe178ee3b0b", size = 3030306 }, - { url = "https://files.pythonhosted.org/packages/a4/5c/467a161f9ed53e5eab51a42923c33051bf8d1a2af4626ac04f5166e58e0c/pillow-11.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25a5f306095c6780c52e6bbb6109624b95c5b18e40aab1c3041da3e9e0cd3e2d", size = 4416121 }, - { url = "https://files.pythonhosted.org/packages/62/73/972b7742e38ae0e2ac76ab137ca6005dcf877480da0d9d61d93b613065b4/pillow-11.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c7b29dbd4281923a2bfe562acb734cee96bbb129e96e6972d315ed9f232bef4", size = 4501707 }, - { url = "https://files.pythonhosted.org/packages/e4/3a/427e4cb0b9e177efbc1a84798ed20498c4f233abde003c06d2650a6d60cb/pillow-11.2.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3e645b020f3209a0181a418bffe7b4a93171eef6c4ef6cc20980b30bebf17b7d", size = 4522921 }, - { url = "https://files.pythonhosted.org/packages/fe/7c/d8b1330458e4d2f3f45d9508796d7caf0c0d3764c00c823d10f6f1a3b76d/pillow-11.2.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b2dbea1012ccb784a65349f57bbc93730b96e85b42e9bf7b01ef40443db720b4", size = 4612523 }, - { url = "https://files.pythonhosted.org/packages/b3/2f/65738384e0b1acf451de5a573d8153fe84103772d139e1e0bdf1596be2ea/pillow-11.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:da3104c57bbd72948d75f6a9389e6727d2ab6333c3617f0a89d72d4940aa0443", size = 4587836 }, - { url = "https://files.pythonhosted.org/packages/6a/c5/e795c9f2ddf3debb2dedd0df889f2fe4b053308bb59a3cc02a0cd144d641/pillow-11.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:598174aef4589af795f66f9caab87ba4ff860ce08cd5bb447c6fc553ffee603c", size = 4669390 }, - { url = "https://files.pythonhosted.org/packages/96/ae/ca0099a3995976a9fce2f423166f7bff9b12244afdc7520f6ed38911539a/pillow-11.2.1-cp312-cp312-win32.whl", hash = "sha256:1d535df14716e7f8776b9e7fee118576d65572b4aad3ed639be9e4fa88a1cad3", size = 2332309 }, - { url = "https://files.pythonhosted.org/packages/7c/18/24bff2ad716257fc03da964c5e8f05d9790a779a8895d6566e493ccf0189/pillow-11.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:14e33b28bf17c7a38eede290f77db7c664e4eb01f7869e37fa98a5aa95978941", size = 2676768 }, - { url = "https://files.pythonhosted.org/packages/da/bb/e8d656c9543276517ee40184aaa39dcb41e683bca121022f9323ae11b39d/pillow-11.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:21e1470ac9e5739ff880c211fc3af01e3ae505859392bf65458c224d0bf283eb", size = 2415087 }, - { url = "https://files.pythonhosted.org/packages/a4/ad/2613c04633c7257d9481ab21d6b5364b59fc5d75faafd7cb8693523945a3/pillow-11.2.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:80f1df8dbe9572b4b7abdfa17eb5d78dd620b1d55d9e25f834efdbee872d3aed", size = 3181734 }, - { url = "https://files.pythonhosted.org/packages/a4/fd/dcdda4471ed667de57bb5405bb42d751e6cfdd4011a12c248b455c778e03/pillow-11.2.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ea926cfbc3957090becbcbbb65ad177161a2ff2ad578b5a6ec9bb1e1cd78753c", size = 2999841 }, - { url = "https://files.pythonhosted.org/packages/ac/89/8a2536e95e77432833f0db6fd72a8d310c8e4272a04461fb833eb021bf94/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:738db0e0941ca0376804d4de6a782c005245264edaa253ffce24e5a15cbdc7bd", size = 3437470 }, - { url = "https://files.pythonhosted.org/packages/9d/8f/abd47b73c60712f88e9eda32baced7bfc3e9bd6a7619bb64b93acff28c3e/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db98ab6565c69082ec9b0d4e40dd9f6181dab0dd236d26f7a50b8b9bfbd5076", size = 3460013 }, - { url = "https://files.pythonhosted.org/packages/f6/20/5c0a0aa83b213b7a07ec01e71a3d6ea2cf4ad1d2c686cc0168173b6089e7/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:036e53f4170e270ddb8797d4c590e6dd14d28e15c7da375c18978045f7e6c37b", size = 3527165 }, - { url = "https://files.pythonhosted.org/packages/58/0e/2abab98a72202d91146abc839e10c14f7cf36166f12838ea0c4db3ca6ecb/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:14f73f7c291279bd65fda51ee87affd7c1e097709f7fdd0188957a16c264601f", size = 3571586 }, - { url = "https://files.pythonhosted.org/packages/21/2c/5e05f58658cf49b6667762cca03d6e7d85cededde2caf2ab37b81f80e574/pillow-11.2.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:208653868d5c9ecc2b327f9b9ef34e0e42a4cdd172c2988fd81d62d2bc9bc044", size = 2674751 }, + { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531 }, + { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560 }, + { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978 }, + { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168 }, + { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053 }, + { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273 }, + { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043 }, + { url = "https://files.pythonhosted.org/packages/3a/04/ba8f2b11fc80d2dd462d7abec16351b45ec99cbbaea4387648a44190351a/pillow-11.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94", size = 6715516 }, + { url = "https://files.pythonhosted.org/packages/48/59/8cd06d7f3944cc7d892e8533c56b0acb68399f640786313275faec1e3b6f/pillow-11.3.0-cp311-cp311-win32.whl", hash = "sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0", size = 6274768 }, + { url = "https://files.pythonhosted.org/packages/f1/cc/29c0f5d64ab8eae20f3232da8f8571660aa0ab4b8f1331da5c2f5f9a938e/pillow-11.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac", size = 6986055 }, + { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079 }, + { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800 }, + { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296 }, + { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726 }, + { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652 }, + { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787 }, + { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236 }, + { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950 }, + { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358 }, + { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079 }, + { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324 }, + { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067 }, + { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566 }, + { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618 }, + { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248 }, + { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963 }, + { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170 }, + { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505 }, + { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598 }, ] [[package]] @@ -3065,75 +2289,27 @@ wheels = [ ] [[package]] -name = "pluggy" -version = "1.6.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 }, -] - -[[package]] -name = "plumbum" -version = "1.9.0" +name = "podcast-creator" +version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and platform_system == 'Windows'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f0/5d/49ba324ad4ae5b1a4caefafbce7a1648540129344481f2ed4ef6bb68d451/plumbum-1.9.0.tar.gz", hash = "sha256:e640062b72642c3873bd5bdc3effed75ba4d3c70ef6b6a7b907357a84d909219", size = 319083 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4f/9d/d03542c93bb3d448406731b80f39c3d5601282f778328c22c77d270f4ed4/plumbum-1.9.0-py3-none-any.whl", hash = "sha256:9fd0d3b0e8d86e4b581af36edf3f3bbe9d1ae15b45b8caab28de1bcb27aaa7f5", size = 127970 }, -] - -[[package]] -name = "ply" -version = "3.11" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e5/69/882ee5c9d017149285cab114ebeab373308ef0f874fcdac9beb90e0ac4da/ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", size = 159130 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567 }, -] - -[[package]] -name = "podcastfy" -version = "0.4.1" -source = { git = "https://github.com/lfnovo/podcastfy#41e42dc4caacacf307a7f5a31905c93dfa06992f" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "cython" }, - { name = "edge-tts" }, - { name = "elevenlabs" }, - { name = "ffmpeg" }, - { name = "fuzzywuzzy" }, - { name = "google-cloud-texttospeech" }, - { name = "google-generativeai" }, - { name = "httpx" }, - { name = "langchain" }, - { name = "langchain-community" }, - { name = "langchain-google-genai" }, - { name = "langchain-google-vertexai" }, - { name = "litellm" }, - { name = "nbsphinx" }, + { name = "ai-prompter" }, + { name = "click" }, + { name = "content-core" }, + { name = "esperanto" }, + { name = "langchain-openai" }, + { name = "langgraph" }, + { name = "loguru" }, + { name = "moviepy" }, { name = "nest-asyncio" }, - { name = "numpy" }, - { name = "openai" }, - { name = "pandas" }, - { name = "pandoc" }, { name = "pydub" }, - { name = "pymupdf" }, - { name = "pytest" }, - { name = "pytest-xdist" }, { name = "python-dotenv" }, - { name = "python-levenshtein" }, - { name = "pyyaml" }, { name = "requests" }, - { name = "setuptools" }, - { name = "sphinx-autodoc-typehints" }, - { name = "sphinx-rtd-theme" }, - { name = "typer" }, - { name = "types-pyyaml" }, - { name = "wheel" }, - { name = "youtube-transcript-api" }, + { name = "tiktoken" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/ef/05edc7806059f0c1750e1a7f341d10dd1769e6c3766b676f7df60d6fecf5/podcast_creator-0.5.0.tar.gz", hash = "sha256:5de748e1216e7260c87d1b136a6bb1aff24d87930bbffa8d97a6df3648ae4110", size = 333126 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/16/7d220f40e43025f06427cb9e1e4518bffbeb0da7208d52237f39dedd8f48/podcast_creator-0.5.0-py3-none-any.whl", hash = "sha256:e5d9cc5949b97205b0d18af8070587b5b8ebc9852f5ce50cceca8d9918ad7af4", size = 116001 }, ] [[package]] @@ -3178,43 +2354,43 @@ wheels = [ [[package]] name = "propcache" -version = "0.3.2" +version = "0.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/16/43264e4a779dd8588c21a70f0709665ee8f611211bdd2c87d952cfa7c776/propcache-0.3.2.tar.gz", hash = "sha256:20d7d62e4e7ef05f221e0db2856b979540686342e7dd9973b815599c7057e168", size = 44139 } +sdist = { url = "https://files.pythonhosted.org/packages/20/c8/2a13f78d82211490855b2fb303b6721348d0787fdd9a12ac46d99d3acde1/propcache-0.2.1.tar.gz", hash = "sha256:3f77ce728b19cb537714499928fe800c3dda29e8d9428778fc7c186da4c09a64", size = 41735 } wheels = [ - { url = "https://files.pythonhosted.org/packages/80/8d/e8b436717ab9c2cfc23b116d2c297305aa4cd8339172a456d61ebf5669b8/propcache-0.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0b8d2f607bd8f80ddc04088bc2a037fdd17884a6fcadc47a96e334d72f3717be", size = 74207 }, - { url = "https://files.pythonhosted.org/packages/d6/29/1e34000e9766d112171764b9fa3226fa0153ab565d0c242c70e9945318a7/propcache-0.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06766d8f34733416e2e34f46fea488ad5d60726bb9481d3cddf89a6fa2d9603f", size = 43648 }, - { url = "https://files.pythonhosted.org/packages/46/92/1ad5af0df781e76988897da39b5f086c2bf0f028b7f9bd1f409bb05b6874/propcache-0.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2dc1f4a1df4fecf4e6f68013575ff4af84ef6f478fe5344317a65d38a8e6dc9", size = 43496 }, - { url = "https://files.pythonhosted.org/packages/b3/ce/e96392460f9fb68461fabab3e095cb00c8ddf901205be4eae5ce246e5b7e/propcache-0.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be29c4f4810c5789cf10ddf6af80b041c724e629fa51e308a7a0fb19ed1ef7bf", size = 217288 }, - { url = "https://files.pythonhosted.org/packages/c5/2a/866726ea345299f7ceefc861a5e782b045545ae6940851930a6adaf1fca6/propcache-0.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59d61f6970ecbd8ff2e9360304d5c8876a6abd4530cb752c06586849ac8a9dc9", size = 227456 }, - { url = "https://files.pythonhosted.org/packages/de/03/07d992ccb6d930398689187e1b3c718339a1c06b8b145a8d9650e4726166/propcache-0.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:62180e0b8dbb6b004baec00a7983e4cc52f5ada9cd11f48c3528d8cfa7b96a66", size = 225429 }, - { url = "https://files.pythonhosted.org/packages/5d/e6/116ba39448753b1330f48ab8ba927dcd6cf0baea8a0ccbc512dfb49ba670/propcache-0.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c144ca294a204c470f18cf4c9d78887810d04a3e2fbb30eea903575a779159df", size = 213472 }, - { url = "https://files.pythonhosted.org/packages/a6/85/f01f5d97e54e428885a5497ccf7f54404cbb4f906688a1690cd51bf597dc/propcache-0.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5c2a784234c28854878d68978265617aa6dc0780e53d44b4d67f3651a17a9a2", size = 204480 }, - { url = "https://files.pythonhosted.org/packages/e3/79/7bf5ab9033b8b8194cc3f7cf1aaa0e9c3256320726f64a3e1f113a812dce/propcache-0.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5745bc7acdafa978ca1642891b82c19238eadc78ba2aaa293c6863b304e552d7", size = 214530 }, - { url = "https://files.pythonhosted.org/packages/31/0b/bd3e0c00509b609317df4a18e6b05a450ef2d9a963e1d8bc9c9415d86f30/propcache-0.3.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:c0075bf773d66fa8c9d41f66cc132ecc75e5bb9dd7cce3cfd14adc5ca184cb95", size = 205230 }, - { url = "https://files.pythonhosted.org/packages/7a/23/fae0ff9b54b0de4e819bbe559508da132d5683c32d84d0dc2ccce3563ed4/propcache-0.3.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5f57aa0847730daceff0497f417c9de353c575d8da3579162cc74ac294c5369e", size = 206754 }, - { url = "https://files.pythonhosted.org/packages/b7/7f/ad6a3c22630aaa5f618b4dc3c3598974a72abb4c18e45a50b3cdd091eb2f/propcache-0.3.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:eef914c014bf72d18efb55619447e0aecd5fb7c2e3fa7441e2e5d6099bddff7e", size = 218430 }, - { url = "https://files.pythonhosted.org/packages/5b/2c/ba4f1c0e8a4b4c75910742f0d333759d441f65a1c7f34683b4a74c0ee015/propcache-0.3.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2a4092e8549031e82facf3decdbc0883755d5bbcc62d3aea9d9e185549936dcf", size = 223884 }, - { url = "https://files.pythonhosted.org/packages/88/e4/ebe30fc399e98572019eee82ad0caf512401661985cbd3da5e3140ffa1b0/propcache-0.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:85871b050f174bc0bfb437efbdb68aaf860611953ed12418e4361bc9c392749e", size = 211480 }, - { url = "https://files.pythonhosted.org/packages/96/0a/7d5260b914e01d1d0906f7f38af101f8d8ed0dc47426219eeaf05e8ea7c2/propcache-0.3.2-cp311-cp311-win32.whl", hash = "sha256:36c8d9b673ec57900c3554264e630d45980fd302458e4ac801802a7fd2ef7897", size = 37757 }, - { url = "https://files.pythonhosted.org/packages/e1/2d/89fe4489a884bc0da0c3278c552bd4ffe06a1ace559db5ef02ef24ab446b/propcache-0.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53af8cb6a781b02d2ea079b5b853ba9430fcbe18a8e3ce647d5982a3ff69f39", size = 41500 }, - { url = "https://files.pythonhosted.org/packages/a8/42/9ca01b0a6f48e81615dca4765a8f1dd2c057e0540f6116a27dc5ee01dfb6/propcache-0.3.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8de106b6c84506b31c27168582cd3cb3000a6412c16df14a8628e5871ff83c10", size = 73674 }, - { url = "https://files.pythonhosted.org/packages/af/6e/21293133beb550f9c901bbece755d582bfaf2176bee4774000bd4dd41884/propcache-0.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:28710b0d3975117239c76600ea351934ac7b5ff56e60953474342608dbbb6154", size = 43570 }, - { url = "https://files.pythonhosted.org/packages/0c/c8/0393a0a3a2b8760eb3bde3c147f62b20044f0ddac81e9d6ed7318ec0d852/propcache-0.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce26862344bdf836650ed2487c3d724b00fbfec4233a1013f597b78c1cb73615", size = 43094 }, - { url = "https://files.pythonhosted.org/packages/37/2c/489afe311a690399d04a3e03b069225670c1d489eb7b044a566511c1c498/propcache-0.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bca54bd347a253af2cf4544bbec232ab982f4868de0dd684246b67a51bc6b1db", size = 226958 }, - { url = "https://files.pythonhosted.org/packages/9d/ca/63b520d2f3d418c968bf596839ae26cf7f87bead026b6192d4da6a08c467/propcache-0.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55780d5e9a2ddc59711d727226bb1ba83a22dd32f64ee15594b9392b1f544eb1", size = 234894 }, - { url = "https://files.pythonhosted.org/packages/11/60/1d0ed6fff455a028d678df30cc28dcee7af77fa2b0e6962ce1df95c9a2a9/propcache-0.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:035e631be25d6975ed87ab23153db6a73426a48db688070d925aa27e996fe93c", size = 233672 }, - { url = "https://files.pythonhosted.org/packages/37/7c/54fd5301ef38505ab235d98827207176a5c9b2aa61939b10a460ca53e123/propcache-0.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee6f22b6eaa39297c751d0e80c0d3a454f112f5c6481214fcf4c092074cecd67", size = 224395 }, - { url = "https://files.pythonhosted.org/packages/ee/1a/89a40e0846f5de05fdc6779883bf46ba980e6df4d2ff8fb02643de126592/propcache-0.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ca3aee1aa955438c4dba34fc20a9f390e4c79967257d830f137bd5a8a32ed3b", size = 212510 }, - { url = "https://files.pythonhosted.org/packages/5e/33/ca98368586c9566a6b8d5ef66e30484f8da84c0aac3f2d9aec6d31a11bd5/propcache-0.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4f30862869fa2b68380d677cc1c5fcf1e0f2b9ea0cf665812895c75d0ca3b8", size = 222949 }, - { url = "https://files.pythonhosted.org/packages/ba/11/ace870d0aafe443b33b2f0b7efdb872b7c3abd505bfb4890716ad7865e9d/propcache-0.3.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b77ec3c257d7816d9f3700013639db7491a434644c906a2578a11daf13176251", size = 217258 }, - { url = "https://files.pythonhosted.org/packages/5b/d2/86fd6f7adffcfc74b42c10a6b7db721d1d9ca1055c45d39a1a8f2a740a21/propcache-0.3.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cab90ac9d3f14b2d5050928483d3d3b8fb6b4018893fc75710e6aa361ecb2474", size = 213036 }, - { url = "https://files.pythonhosted.org/packages/07/94/2d7d1e328f45ff34a0a284cf5a2847013701e24c2a53117e7c280a4316b3/propcache-0.3.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:0b504d29f3c47cf6b9e936c1852246c83d450e8e063d50562115a6be6d3a2535", size = 227684 }, - { url = "https://files.pythonhosted.org/packages/b7/05/37ae63a0087677e90b1d14710e532ff104d44bc1efa3b3970fff99b891dc/propcache-0.3.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:ce2ac2675a6aa41ddb2a0c9cbff53780a617ac3d43e620f8fd77ba1c84dcfc06", size = 234562 }, - { url = "https://files.pythonhosted.org/packages/a4/7c/3f539fcae630408d0bd8bf3208b9a647ccad10976eda62402a80adf8fc34/propcache-0.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:62b4239611205294cc433845b914131b2a1f03500ff3c1ed093ed216b82621e1", size = 222142 }, - { url = "https://files.pythonhosted.org/packages/7c/d2/34b9eac8c35f79f8a962546b3e97e9d4b990c420ee66ac8255d5d9611648/propcache-0.3.2-cp312-cp312-win32.whl", hash = "sha256:df4a81b9b53449ebc90cc4deefb052c1dd934ba85012aa912c7ea7b7e38b60c1", size = 37711 }, - { url = "https://files.pythonhosted.org/packages/19/61/d582be5d226cf79071681d1b46b848d6cb03d7b70af7063e33a2787eaa03/propcache-0.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:7046e79b989d7fe457bb755844019e10f693752d169076138abf17f31380800c", size = 41479 }, - { url = "https://files.pythonhosted.org/packages/cc/35/cc0aaecf278bb4575b8555f2b137de5ab821595ddae9da9d3cd1da4072c7/propcache-0.3.2-py3-none-any.whl", hash = "sha256:98f1ec44fb675f5052cccc8e609c46ed23a35a1cfd18545ad4e29002d858a43f", size = 12663 }, + { url = "https://files.pythonhosted.org/packages/bc/0f/2913b6791ebefb2b25b4efd4bb2299c985e09786b9f5b19184a88e5778dd/propcache-0.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ffc3cca89bb438fb9c95c13fc874012f7b9466b89328c3c8b1aa93cdcfadd16", size = 79297 }, + { url = "https://files.pythonhosted.org/packages/cf/73/af2053aeccd40b05d6e19058419ac77674daecdd32478088b79375b9ab54/propcache-0.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f174bbd484294ed9fdf09437f889f95807e5f229d5d93588d34e92106fbf6717", size = 45611 }, + { url = "https://files.pythonhosted.org/packages/3c/09/8386115ba7775ea3b9537730e8cf718d83bbf95bffe30757ccf37ec4e5da/propcache-0.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:70693319e0b8fd35dd863e3e29513875eb15c51945bf32519ef52927ca883bc3", size = 45146 }, + { url = "https://files.pythonhosted.org/packages/03/7a/793aa12f0537b2e520bf09f4c6833706b63170a211ad042ca71cbf79d9cb/propcache-0.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b480c6a4e1138e1aa137c0079b9b6305ec6dcc1098a8ca5196283e8a49df95a9", size = 232136 }, + { url = "https://files.pythonhosted.org/packages/f1/38/b921b3168d72111769f648314100558c2ea1d52eb3d1ba7ea5c4aa6f9848/propcache-0.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d27b84d5880f6d8aa9ae3edb253c59d9f6642ffbb2c889b78b60361eed449787", size = 239706 }, + { url = "https://files.pythonhosted.org/packages/14/29/4636f500c69b5edea7786db3c34eb6166f3384b905665ce312a6e42c720c/propcache-0.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:857112b22acd417c40fa4595db2fe28ab900c8c5fe4670c7989b1c0230955465", size = 238531 }, + { url = "https://files.pythonhosted.org/packages/85/14/01fe53580a8e1734ebb704a3482b7829a0ef4ea68d356141cf0994d9659b/propcache-0.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf6c4150f8c0e32d241436526f3c3f9cbd34429492abddbada2ffcff506c51af", size = 231063 }, + { url = "https://files.pythonhosted.org/packages/33/5c/1d961299f3c3b8438301ccfbff0143b69afcc30c05fa28673cface692305/propcache-0.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66d4cfda1d8ed687daa4bc0274fcfd5267873db9a5bc0418c2da19273040eeb7", size = 220134 }, + { url = "https://files.pythonhosted.org/packages/00/d0/ed735e76db279ba67a7d3b45ba4c654e7b02bc2f8050671ec365d8665e21/propcache-0.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2f992c07c0fca81655066705beae35fc95a2fa7366467366db627d9f2ee097f", size = 220009 }, + { url = "https://files.pythonhosted.org/packages/75/90/ee8fab7304ad6533872fee982cfff5a53b63d095d78140827d93de22e2d4/propcache-0.2.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:4a571d97dbe66ef38e472703067021b1467025ec85707d57e78711c085984e54", size = 212199 }, + { url = "https://files.pythonhosted.org/packages/eb/ec/977ffaf1664f82e90737275873461695d4c9407d52abc2f3c3e24716da13/propcache-0.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bb6178c241278d5fe853b3de743087be7f5f4c6f7d6d22a3b524d323eecec505", size = 214827 }, + { url = "https://files.pythonhosted.org/packages/57/48/031fb87ab6081764054821a71b71942161619549396224cbb242922525e8/propcache-0.2.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:ad1af54a62ffe39cf34db1aa6ed1a1873bd548f6401db39d8e7cd060b9211f82", size = 228009 }, + { url = "https://files.pythonhosted.org/packages/1a/06/ef1390f2524850838f2390421b23a8b298f6ce3396a7cc6d39dedd4047b0/propcache-0.2.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e7048abd75fe40712005bcfc06bb44b9dfcd8e101dda2ecf2f5aa46115ad07ca", size = 231638 }, + { url = "https://files.pythonhosted.org/packages/38/2a/101e6386d5a93358395da1d41642b79c1ee0f3b12e31727932b069282b1d/propcache-0.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:160291c60081f23ee43d44b08a7e5fb76681221a8e10b3139618c5a9a291b84e", size = 222788 }, + { url = "https://files.pythonhosted.org/packages/db/81/786f687951d0979007e05ad9346cd357e50e3d0b0f1a1d6074df334b1bbb/propcache-0.2.1-cp311-cp311-win32.whl", hash = "sha256:819ce3b883b7576ca28da3861c7e1a88afd08cc8c96908e08a3f4dd64a228034", size = 40170 }, + { url = "https://files.pythonhosted.org/packages/cf/59/7cc7037b295d5772eceb426358bb1b86e6cab4616d971bd74275395d100d/propcache-0.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:edc9fc7051e3350643ad929df55c451899bb9ae6d24998a949d2e4c87fb596d3", size = 44404 }, + { url = "https://files.pythonhosted.org/packages/4c/28/1d205fe49be8b1b4df4c50024e62480a442b1a7b818e734308bb0d17e7fb/propcache-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:081a430aa8d5e8876c6909b67bd2d937bfd531b0382d3fdedb82612c618bc41a", size = 79588 }, + { url = "https://files.pythonhosted.org/packages/21/ee/fc4d893f8d81cd4971affef2a6cb542b36617cd1d8ce56b406112cb80bf7/propcache-0.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2ccec9ac47cf4e04897619c0e0c1a48c54a71bdf045117d3a26f80d38ab1fb0", size = 45825 }, + { url = "https://files.pythonhosted.org/packages/4a/de/bbe712f94d088da1d237c35d735f675e494a816fd6f54e9db2f61ef4d03f/propcache-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:14d86fe14b7e04fa306e0c43cdbeebe6b2c2156a0c9ce56b815faacc193e320d", size = 45357 }, + { url = "https://files.pythonhosted.org/packages/7f/14/7ae06a6cf2a2f1cb382586d5a99efe66b0b3d0c6f9ac2f759e6f7af9d7cf/propcache-0.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:049324ee97bb67285b49632132db351b41e77833678432be52bdd0289c0e05e4", size = 241869 }, + { url = "https://files.pythonhosted.org/packages/cc/59/227a78be960b54a41124e639e2c39e8807ac0c751c735a900e21315f8c2b/propcache-0.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cd9a1d071158de1cc1c71a26014dcdfa7dd3d5f4f88c298c7f90ad6f27bb46d", size = 247884 }, + { url = "https://files.pythonhosted.org/packages/84/58/f62b4ffaedf88dc1b17f04d57d8536601e4e030feb26617228ef930c3279/propcache-0.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98110aa363f1bb4c073e8dcfaefd3a5cea0f0834c2aab23dda657e4dab2f53b5", size = 248486 }, + { url = "https://files.pythonhosted.org/packages/1c/07/ebe102777a830bca91bbb93e3479cd34c2ca5d0361b83be9dbd93104865e/propcache-0.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:647894f5ae99c4cf6bb82a1bb3a796f6e06af3caa3d32e26d2350d0e3e3faf24", size = 243649 }, + { url = "https://files.pythonhosted.org/packages/ed/bc/4f7aba7f08f520376c4bb6a20b9a981a581b7f2e385fa0ec9f789bb2d362/propcache-0.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfd3223c15bebe26518d58ccf9a39b93948d3dcb3e57a20480dfdd315356baff", size = 229103 }, + { url = "https://files.pythonhosted.org/packages/fe/d5/04ac9cd4e51a57a96f78795e03c5a0ddb8f23ec098b86f92de028d7f2a6b/propcache-0.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d71264a80f3fcf512eb4f18f59423fe82d6e346ee97b90625f283df56aee103f", size = 226607 }, + { url = "https://files.pythonhosted.org/packages/e3/f0/24060d959ea41d7a7cc7fdbf68b31852331aabda914a0c63bdb0e22e96d6/propcache-0.2.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e73091191e4280403bde6c9a52a6999d69cdfde498f1fdf629105247599b57ec", size = 221153 }, + { url = "https://files.pythonhosted.org/packages/77/a7/3ac76045a077b3e4de4859a0753010765e45749bdf53bd02bc4d372da1a0/propcache-0.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3935bfa5fede35fb202c4b569bb9c042f337ca4ff7bd540a0aa5e37131659348", size = 222151 }, + { url = "https://files.pythonhosted.org/packages/e7/af/5e29da6f80cebab3f5a4dcd2a3240e7f56f2c4abf51cbfcc99be34e17f0b/propcache-0.2.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f508b0491767bb1f2b87fdfacaba5f7eddc2f867740ec69ece6d1946d29029a6", size = 233812 }, + { url = "https://files.pythonhosted.org/packages/8c/89/ebe3ad52642cc5509eaa453e9f4b94b374d81bae3265c59d5c2d98efa1b4/propcache-0.2.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1672137af7c46662a1c2be1e8dc78cb6d224319aaa40271c9257d886be4363a6", size = 238829 }, + { url = "https://files.pythonhosted.org/packages/e9/2f/6b32f273fa02e978b7577159eae7471b3cfb88b48563b1c2578b2d7ca0bb/propcache-0.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b74c261802d3d2b85c9df2dfb2fa81b6f90deeef63c2db9f0e029a3cac50b518", size = 230704 }, + { url = "https://files.pythonhosted.org/packages/5c/2e/f40ae6ff5624a5f77edd7b8359b208b5455ea113f68309e2b00a2e1426b6/propcache-0.2.1-cp312-cp312-win32.whl", hash = "sha256:d09c333d36c1409d56a9d29b3a1b800a42c76a57a5a8907eacdbce3f18768246", size = 40050 }, + { url = "https://files.pythonhosted.org/packages/3b/77/a92c3ef994e47180862b9d7d11e37624fb1c00a16d61faf55115d970628b/propcache-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:c214999039d4f2a5b2073ac506bba279945233da8c786e490d411dfc30f855c1", size = 44117 }, + { url = "https://files.pythonhosted.org/packages/41/b6/c5319caea262f4821995dca2107483b94a3345d4607ad797c76cb9c36bcc/propcache-0.2.1-py3-none-any.whl", hash = "sha256:52277518d6aae65536e9cea52d4e7fd2f7a66f4aa2d30ed3f2fcea620ace3c54", size = 11818 }, ] [[package]] @@ -3231,16 +2407,16 @@ wheels = [ [[package]] name = "protobuf" -version = "5.29.5" +version = "6.31.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/29/d09e70352e4e88c9c7a198d5645d7277811448d76c23b00345670f7c8a38/protobuf-5.29.5.tar.gz", hash = "sha256:bc1463bafd4b0929216c35f437a8e28731a2b7fe3d98bb77a600efced5a15c84", size = 425226 } +sdist = { url = "https://files.pythonhosted.org/packages/52/f3/b9655a711b32c19720253f6f06326faf90580834e2e83f840472d752bc8b/protobuf-6.31.1.tar.gz", hash = "sha256:d8cac4c982f0b957a4dc73a80e2ea24fab08e679c0de9deb835f4a12d69aca9a", size = 441797 } wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/11/6e40e9fc5bba02988a214c07cf324595789ca7820160bfd1f8be96e48539/protobuf-5.29.5-cp310-abi3-win32.whl", hash = "sha256:3f1c6468a2cfd102ff4703976138844f78ebd1fb45f49011afc5139e9e283079", size = 422963 }, - { url = "https://files.pythonhosted.org/packages/81/7f/73cefb093e1a2a7c3ffd839e6f9fcafb7a427d300c7f8aef9c64405d8ac6/protobuf-5.29.5-cp310-abi3-win_amd64.whl", hash = "sha256:3f76e3a3675b4a4d867b52e4a5f5b78a2ef9565549d4037e06cf7b0942b1d3fc", size = 434818 }, - { url = "https://files.pythonhosted.org/packages/dd/73/10e1661c21f139f2c6ad9b23040ff36fee624310dc28fba20d33fdae124c/protobuf-5.29.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e38c5add5a311f2a6eb0340716ef9b039c1dfa428b28f25a7838ac329204a671", size = 418091 }, - { url = "https://files.pythonhosted.org/packages/6c/04/98f6f8cf5b07ab1294c13f34b4e69b3722bb609c5b701d6c169828f9f8aa/protobuf-5.29.5-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:fa18533a299d7ab6c55a238bf8629311439995f2e7eca5caaff08663606e9015", size = 319824 }, - { url = "https://files.pythonhosted.org/packages/85/e4/07c80521879c2d15f321465ac24c70efe2381378c00bf5e56a0f4fbac8cd/protobuf-5.29.5-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:63848923da3325e1bf7e9003d680ce6e14b07e55d0473253a690c3a8b8fd6e61", size = 319942 }, - { url = "https://files.pythonhosted.org/packages/7e/cc/7e77861000a0691aeea8f4566e5d3aa716f2b1dece4a24439437e41d3d25/protobuf-5.29.5-py3-none-any.whl", hash = "sha256:6cf42630262c59b2d8de33954443d94b746c952b01434fc58a417fdbd2e84bd5", size = 172823 }, + { url = "https://files.pythonhosted.org/packages/f3/6f/6ab8e4bf962fd5570d3deaa2d5c38f0a363f57b4501047b5ebeb83ab1125/protobuf-6.31.1-cp310-abi3-win32.whl", hash = "sha256:7fa17d5a29c2e04b7d90e5e32388b8bfd0e7107cd8e616feef7ed3fa6bdab5c9", size = 423603 }, + { url = "https://files.pythonhosted.org/packages/44/3a/b15c4347dd4bf3a1b0ee882f384623e2063bb5cf9fa9d57990a4f7df2fb6/protobuf-6.31.1-cp310-abi3-win_amd64.whl", hash = "sha256:426f59d2964864a1a366254fa703b8632dcec0790d8862d30034d8245e1cd447", size = 435283 }, + { url = "https://files.pythonhosted.org/packages/6a/c9/b9689a2a250264a84e66c46d8862ba788ee7a641cdca39bccf64f59284b7/protobuf-6.31.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:6f1227473dc43d44ed644425268eb7c2e488ae245d51c6866d19fe158e207402", size = 425604 }, + { url = "https://files.pythonhosted.org/packages/76/a1/7a5a94032c83375e4fe7e7f56e3976ea6ac90c5e85fac8576409e25c39c3/protobuf-6.31.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:a40fc12b84c154884d7d4c4ebd675d5b3b5283e155f324049ae396b95ddebc39", size = 322115 }, + { url = "https://files.pythonhosted.org/packages/fa/b1/b59d405d64d31999244643d88c45c8241c58f17cc887e73bcb90602327f8/protobuf-6.31.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:4ee898bf66f7a8b0bd21bce523814e6fbd8c6add948045ce958b73af7e8878c6", size = 321070 }, + { url = "https://files.pythonhosted.org/packages/f7/af/ab3c51ab7507a7325e98ffe691d9495ee3d3aa5f589afad65ec920d39821/protobuf-6.31.1-py3-none-any.whl", hash = "sha256:720a6c7e6b77288b85063569baae8536671b39f15cc22037ec7045658d80489e", size = 168724 }, ] [[package]] @@ -3278,28 +2454,24 @@ wheels = [ [[package]] name = "pyarrow" -version = "20.0.0" +version = "19.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/ee/a7810cb9f3d6e9238e61d312076a9859bf3668fd21c69744de9532383912/pyarrow-20.0.0.tar.gz", hash = "sha256:febc4a913592573c8d5805091a6c2b5064c8bd6e002131f01061797d91c783c1", size = 1125187 } +sdist = { url = "https://files.pythonhosted.org/packages/7f/09/a9046344212690f0632b9c709f9bf18506522feb333c894d0de81d62341a/pyarrow-19.0.1.tar.gz", hash = "sha256:3bf266b485df66a400f282ac0b6d1b500b9d2ae73314a153dbe97d6d5cc8a99e", size = 1129437 } wheels = [ - { url = "https://files.pythonhosted.org/packages/47/a2/b7930824181ceadd0c63c1042d01fa4ef63eee233934826a7a2a9af6e463/pyarrow-20.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:24ca380585444cb2a31324c546a9a56abbe87e26069189e14bdba19c86c049f0", size = 30856035 }, - { url = "https://files.pythonhosted.org/packages/9b/18/c765770227d7f5bdfa8a69f64b49194352325c66a5c3bb5e332dfd5867d9/pyarrow-20.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:95b330059ddfdc591a3225f2d272123be26c8fa76e8c9ee1a77aad507361cfdb", size = 32309552 }, - { url = "https://files.pythonhosted.org/packages/44/fb/dfb2dfdd3e488bb14f822d7335653092dde150cffc2da97de6e7500681f9/pyarrow-20.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f0fb1041267e9968c6d0d2ce3ff92e3928b243e2b6d11eeb84d9ac547308232", size = 41334704 }, - { url = "https://files.pythonhosted.org/packages/58/0d/08a95878d38808051a953e887332d4a76bc06c6ee04351918ee1155407eb/pyarrow-20.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8ff87cc837601532cc8242d2f7e09b4e02404de1b797aee747dd4ba4bd6313f", size = 42399836 }, - { url = "https://files.pythonhosted.org/packages/f3/cd/efa271234dfe38f0271561086eedcad7bc0f2ddd1efba423916ff0883684/pyarrow-20.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:7a3a5dcf54286e6141d5114522cf31dd67a9e7c9133d150799f30ee302a7a1ab", size = 40711789 }, - { url = "https://files.pythonhosted.org/packages/46/1f/7f02009bc7fc8955c391defee5348f510e589a020e4b40ca05edcb847854/pyarrow-20.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a6ad3e7758ecf559900261a4df985662df54fb7fdb55e8e3b3aa99b23d526b62", size = 42301124 }, - { url = "https://files.pythonhosted.org/packages/4f/92/692c562be4504c262089e86757a9048739fe1acb4024f92d39615e7bab3f/pyarrow-20.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6bb830757103a6cb300a04610e08d9636f0cd223d32f388418ea893a3e655f1c", size = 42916060 }, - { url = "https://files.pythonhosted.org/packages/a4/ec/9f5c7e7c828d8e0a3c7ef50ee62eca38a7de2fa6eb1b8fa43685c9414fef/pyarrow-20.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96e37f0766ecb4514a899d9a3554fadda770fb57ddf42b63d80f14bc20aa7db3", size = 44547640 }, - { url = "https://files.pythonhosted.org/packages/54/96/46613131b4727f10fd2ffa6d0d6f02efcc09a0e7374eff3b5771548aa95b/pyarrow-20.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:3346babb516f4b6fd790da99b98bed9708e3f02e734c84971faccb20736848dc", size = 25781491 }, - { url = "https://files.pythonhosted.org/packages/a1/d6/0c10e0d54f6c13eb464ee9b67a68b8c71bcf2f67760ef5b6fbcddd2ab05f/pyarrow-20.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:75a51a5b0eef32727a247707d4755322cb970be7e935172b6a3a9f9ae98404ba", size = 30815067 }, - { url = "https://files.pythonhosted.org/packages/7e/e2/04e9874abe4094a06fd8b0cbb0f1312d8dd7d707f144c2ec1e5e8f452ffa/pyarrow-20.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:211d5e84cecc640c7a3ab900f930aaff5cd2702177e0d562d426fb7c4f737781", size = 32297128 }, - { url = "https://files.pythonhosted.org/packages/31/fd/c565e5dcc906a3b471a83273039cb75cb79aad4a2d4a12f76cc5ae90a4b8/pyarrow-20.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ba3cf4182828be7a896cbd232aa8dd6a31bd1f9e32776cc3796c012855e1199", size = 41334890 }, - { url = "https://files.pythonhosted.org/packages/af/a9/3bdd799e2c9b20c1ea6dc6fa8e83f29480a97711cf806e823f808c2316ac/pyarrow-20.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c3a01f313ffe27ac4126f4c2e5ea0f36a5fc6ab51f8726cf41fee4b256680bd", size = 42421775 }, - { url = "https://files.pythonhosted.org/packages/10/f7/da98ccd86354c332f593218101ae56568d5dcedb460e342000bd89c49cc1/pyarrow-20.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:a2791f69ad72addd33510fec7bb14ee06c2a448e06b649e264c094c5b5f7ce28", size = 40687231 }, - { url = "https://files.pythonhosted.org/packages/bb/1b/2168d6050e52ff1e6cefc61d600723870bf569cbf41d13db939c8cf97a16/pyarrow-20.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4250e28a22302ce8692d3a0e8ec9d9dde54ec00d237cff4dfa9c1fbf79e472a8", size = 42295639 }, - { url = "https://files.pythonhosted.org/packages/b2/66/2d976c0c7158fd25591c8ca55aee026e6d5745a021915a1835578707feb3/pyarrow-20.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:89e030dc58fc760e4010148e6ff164d2f44441490280ef1e97a542375e41058e", size = 42908549 }, - { url = "https://files.pythonhosted.org/packages/31/a9/dfb999c2fc6911201dcbf348247f9cc382a8990f9ab45c12eabfd7243a38/pyarrow-20.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6102b4864d77102dbbb72965618e204e550135a940c2534711d5ffa787df2a5a", size = 44557216 }, - { url = "https://files.pythonhosted.org/packages/a0/8e/9adee63dfa3911be2382fb4d92e4b2e7d82610f9d9f668493bebaa2af50f/pyarrow-20.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:96d6a0a37d9c98be08f5ed6a10831d88d52cac7b13f5287f1e0f625a0de8062b", size = 25660496 }, + { url = "https://files.pythonhosted.org/packages/a0/55/f1a8d838ec07fe3ca53edbe76f782df7b9aafd4417080eebf0b42aab0c52/pyarrow-19.0.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:cc55d71898ea30dc95900297d191377caba257612f384207fe9f8293b5850f90", size = 30713987 }, + { url = "https://files.pythonhosted.org/packages/13/12/428861540bb54c98a140ae858a11f71d041ef9e501e6b7eb965ca7909505/pyarrow-19.0.1-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:7a544ec12de66769612b2d6988c36adc96fb9767ecc8ee0a4d270b10b1c51e00", size = 32135613 }, + { url = "https://files.pythonhosted.org/packages/2f/8a/23d7cc5ae2066c6c736bce1db8ea7bc9ac3ef97ac7e1c1667706c764d2d9/pyarrow-19.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0148bb4fc158bfbc3d6dfe5001d93ebeed253793fff4435167f6ce1dc4bddeae", size = 41149147 }, + { url = "https://files.pythonhosted.org/packages/a2/7a/845d151bb81a892dfb368bf11db584cf8b216963ccce40a5cf50a2492a18/pyarrow-19.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f24faab6ed18f216a37870d8c5623f9c044566d75ec586ef884e13a02a9d62c5", size = 42178045 }, + { url = "https://files.pythonhosted.org/packages/a7/31/e7282d79a70816132cf6cae7e378adfccce9ae10352d21c2fecf9d9756dd/pyarrow-19.0.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:4982f8e2b7afd6dae8608d70ba5bd91699077323f812a0448d8b7abdff6cb5d3", size = 40532998 }, + { url = "https://files.pythonhosted.org/packages/b8/82/20f3c290d6e705e2ee9c1fa1d5a0869365ee477e1788073d8b548da8b64c/pyarrow-19.0.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:49a3aecb62c1be1d822f8bf629226d4a96418228a42f5b40835c1f10d42e4db6", size = 42084055 }, + { url = "https://files.pythonhosted.org/packages/ff/77/e62aebd343238863f2c9f080ad2ef6ace25c919c6ab383436b5b81cbeef7/pyarrow-19.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:008a4009efdb4ea3d2e18f05cd31f9d43c388aad29c636112c2966605ba33466", size = 25283133 }, + { url = "https://files.pythonhosted.org/packages/78/b4/94e828704b050e723f67d67c3535cf7076c7432cd4cf046e4bb3b96a9c9d/pyarrow-19.0.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:80b2ad2b193e7d19e81008a96e313fbd53157945c7be9ac65f44f8937a55427b", size = 30670749 }, + { url = "https://files.pythonhosted.org/packages/7e/3b/4692965e04bb1df55e2c314c4296f1eb12b4f3052d4cf43d29e076aedf66/pyarrow-19.0.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:ee8dec072569f43835932a3b10c55973593abc00936c202707a4ad06af7cb294", size = 32128007 }, + { url = "https://files.pythonhosted.org/packages/22/f7/2239af706252c6582a5635c35caa17cb4d401cd74a87821ef702e3888957/pyarrow-19.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d5d1ec7ec5324b98887bdc006f4d2ce534e10e60f7ad995e7875ffa0ff9cb14", size = 41144566 }, + { url = "https://files.pythonhosted.org/packages/fb/e3/c9661b2b2849cfefddd9fd65b64e093594b231b472de08ff658f76c732b2/pyarrow-19.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3ad4c0eb4e2a9aeb990af6c09e6fa0b195c8c0e7b272ecc8d4d2b6574809d34", size = 42202991 }, + { url = "https://files.pythonhosted.org/packages/fe/4f/a2c0ed309167ef436674782dfee4a124570ba64299c551e38d3fdaf0a17b/pyarrow-19.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d383591f3dcbe545f6cc62daaef9c7cdfe0dff0fb9e1c8121101cabe9098cfa6", size = 40507986 }, + { url = "https://files.pythonhosted.org/packages/27/2e/29bb28a7102a6f71026a9d70d1d61df926887e36ec797f2e6acfd2dd3867/pyarrow-19.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b4c4156a625f1e35d6c0b2132635a237708944eb41df5fbe7d50f20d20c17832", size = 42087026 }, + { url = "https://files.pythonhosted.org/packages/16/33/2a67c0f783251106aeeee516f4806161e7b481f7d744d0d643d2f30230a5/pyarrow-19.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:5bd1618ae5e5476b7654c7b55a6364ae87686d4724538c24185bbb2952679960", size = 25250108 }, ] [[package]] @@ -3323,26 +2495,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259 }, ] -[[package]] -name = "pyclipper" -version = "1.3.0.post6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4a/b2/550fe500e49c464d73fabcb8cb04d47e4885d6ca4cfc1f5b0a125a95b19a/pyclipper-1.3.0.post6.tar.gz", hash = "sha256:42bff0102fa7a7f2abdd795a2594654d62b786d0c6cd67b72d469114fdeb608c", size = 165909 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/50/a9/66ca5f252dcac93ca076698591b838ba17f9729591edf4b74fef7fbe1414/pyclipper-1.3.0.post6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c4247e7c44b34c87acbf38f99d48fb1acaf5da4a2cf4dcd601a9b24d431be4ef", size = 270930 }, - { url = "https://files.pythonhosted.org/packages/59/fe/2ab5818b3504e179086e54a37ecc245525d069267b8c31b18ec3d0830cbf/pyclipper-1.3.0.post6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:851b3e58106c62a5534a1201295fe20c21714dee2eda68081b37ddb0367e6caa", size = 143411 }, - { url = "https://files.pythonhosted.org/packages/09/f7/b58794f643e033a6d14da7c70f517315c3072f3c5fccdf4232fa8c8090c1/pyclipper-1.3.0.post6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16cc1705a915896d2aff52131c427df02265631279eac849ebda766432714cc0", size = 951754 }, - { url = "https://files.pythonhosted.org/packages/c1/77/846a21957cd4ed266c36705ee340beaa923eb57d2bba013cfd7a5c417cfd/pyclipper-1.3.0.post6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ace1f0753cf71c5c5f6488b8feef5dd0fa8b976ad86b24bb51f708f513df4aac", size = 969608 }, - { url = "https://files.pythonhosted.org/packages/c9/2b/580703daa6606d160caf596522d4cfdf62ae619b062a7ce6f905821a57e8/pyclipper-1.3.0.post6-cp311-cp311-win32.whl", hash = "sha256:dbc828641667142751b1127fd5c4291663490cf05689c85be4c5bcc89aaa236a", size = 100227 }, - { url = "https://files.pythonhosted.org/packages/17/4b/a4cda18e8556d913ff75052585eb0d658500596b5f97fe8401d05123d47b/pyclipper-1.3.0.post6-cp311-cp311-win_amd64.whl", hash = "sha256:1c03f1ae43b18ee07730c3c774cc3cf88a10c12a4b097239b33365ec24a0a14a", size = 110442 }, - { url = "https://files.pythonhosted.org/packages/fc/c8/197d9a1d8354922d24d11d22fb2e0cc1ebc182f8a30496b7ddbe89467ce1/pyclipper-1.3.0.post6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:6363b9d79ba1b5d8f32d1623e797c1e9f994600943402e68d5266067bdde173e", size = 270487 }, - { url = "https://files.pythonhosted.org/packages/8e/8e/eb14eadf054494ad81446e21c4ea163b941747610b0eb9051644395f567e/pyclipper-1.3.0.post6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:32cd7fb9c1c893eb87f82a072dbb5e26224ea7cebbad9dc306d67e1ac62dd229", size = 143469 }, - { url = "https://files.pythonhosted.org/packages/cf/e5/6c4a8df6e904c133bb4c5309d211d31c751db60cbd36a7250c02b05494a1/pyclipper-1.3.0.post6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3aab10e3c10ed8fa60c608fb87c040089b83325c937f98f06450cf9fcfdaf1d", size = 944206 }, - { url = "https://files.pythonhosted.org/packages/76/65/cb014acc41cd5bf6bbfa4671c7faffffb9cee01706642c2dec70c5209ac8/pyclipper-1.3.0.post6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58eae2ff92a8cae1331568df076c4c5775bf946afab0068b217f0cf8e188eb3c", size = 963797 }, - { url = "https://files.pythonhosted.org/packages/80/ec/b40cd81ab7598984167508a5369a2fa31a09fe3b3e3d0b73aa50e06d4b3f/pyclipper-1.3.0.post6-cp312-cp312-win32.whl", hash = "sha256:793b0aa54b914257aa7dc76b793dd4dcfb3c84011d48df7e41ba02b571616eaf", size = 99456 }, - { url = "https://files.pythonhosted.org/packages/24/3a/7d6292e3c94fb6b872d8d7e80d909dc527ee6b0af73b753c63fdde65a7da/pyclipper-1.3.0.post6-cp312-cp312-win_amd64.whl", hash = "sha256:d3f9da96f83b8892504923beb21a481cd4516c19be1d39eb57a92ef1c9a29548", size = 110278 }, -] - [[package]] name = "pycparser" version = "2.22" @@ -3354,65 +2506,79 @@ wheels = [ [[package]] name = "pydantic" -version = "2.9.2" +version = "2.11.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-types" }, { name = "pydantic-core" }, { name = "typing-extensions" }, + { name = "typing-inspection" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a9/b7/d9e3f12af310e1120c21603644a1cd86f59060e040ec5c3a80b8f05fae30/pydantic-2.9.2.tar.gz", hash = "sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f", size = 769917 } +sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350 } wheels = [ - { url = "https://files.pythonhosted.org/packages/df/e4/ba44652d562cbf0bf320e0f3810206149c8a4e99cdbf66da82e97ab53a15/pydantic-2.9.2-py3-none-any.whl", hash = "sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12", size = 434928 }, + { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782 }, ] [[package]] name = "pydantic-core" -version = "2.23.4" +version = "2.33.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e2/aa/6b6a9b9f8537b872f552ddd46dd3da230367754b6f707b8e1e963f515ea3/pydantic_core-2.23.4.tar.gz", hash = "sha256:2584f7cf844ac4d970fba483a717dbe10c1c1c96a969bf65d61ffe94df1b2863", size = 402156 } +sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195 } wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/30/890a583cd3f2be27ecf32b479d5d615710bb926d92da03e3f7838ff3e58b/pydantic_core-2.23.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:77733e3892bb0a7fa797826361ce8a9184d25c8dffaec60b7ffe928153680ba8", size = 1865160 }, - { url = "https://files.pythonhosted.org/packages/1d/9a/b634442e1253bc6889c87afe8bb59447f106ee042140bd57680b3b113ec7/pydantic_core-2.23.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b84d168f6c48fabd1f2027a3d1bdfe62f92cade1fb273a5d68e621da0e44e6d", size = 1776777 }, - { url = "https://files.pythonhosted.org/packages/75/9a/7816295124a6b08c24c96f9ce73085032d8bcbaf7e5a781cd41aa910c891/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df49e7a0861a8c36d089c1ed57d308623d60416dab2647a4a17fe050ba85de0e", size = 1799244 }, - { url = "https://files.pythonhosted.org/packages/a9/8f/89c1405176903e567c5f99ec53387449e62f1121894aa9fc2c4fdc51a59b/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ff02b6d461a6de369f07ec15e465a88895f3223eb75073ffea56b84d9331f607", size = 1805307 }, - { url = "https://files.pythonhosted.org/packages/d5/a5/1a194447d0da1ef492e3470680c66048fef56fc1f1a25cafbea4bc1d1c48/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:996a38a83508c54c78a5f41456b0103c30508fed9abcad0a59b876d7398f25fd", size = 2000663 }, - { url = "https://files.pythonhosted.org/packages/13/a5/1df8541651de4455e7d587cf556201b4f7997191e110bca3b589218745a5/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d97683ddee4723ae8c95d1eddac7c192e8c552da0c73a925a89fa8649bf13eea", size = 2655941 }, - { url = "https://files.pythonhosted.org/packages/44/31/a3899b5ce02c4316865e390107f145089876dff7e1dfc770a231d836aed8/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:216f9b2d7713eb98cb83c80b9c794de1f6b7e3145eef40400c62e86cee5f4e1e", size = 2052105 }, - { url = "https://files.pythonhosted.org/packages/1b/aa/98e190f8745d5ec831f6d5449344c48c0627ac5fed4e5340a44b74878f8e/pydantic_core-2.23.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6f783e0ec4803c787bcea93e13e9932edab72068f68ecffdf86a99fd5918878b", size = 1919967 }, - { url = "https://files.pythonhosted.org/packages/ae/35/b6e00b6abb2acfee3e8f85558c02a0822e9a8b2f2d812ea8b9079b118ba0/pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d0776dea117cf5272382634bd2a5c1b6eb16767c223c6a5317cd3e2a757c61a0", size = 1964291 }, - { url = "https://files.pythonhosted.org/packages/13/46/7bee6d32b69191cd649bbbd2361af79c472d72cb29bb2024f0b6e350ba06/pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d5f7a395a8cf1621939692dba2a6b6a830efa6b3cee787d82c7de1ad2930de64", size = 2109666 }, - { url = "https://files.pythonhosted.org/packages/39/ef/7b34f1b122a81b68ed0a7d0e564da9ccdc9a2924c8d6c6b5b11fa3a56970/pydantic_core-2.23.4-cp311-none-win32.whl", hash = "sha256:74b9127ffea03643e998e0c5ad9bd3811d3dac8c676e47db17b0ee7c3c3bf35f", size = 1732940 }, - { url = "https://files.pythonhosted.org/packages/2f/76/37b7e76c645843ff46c1d73e046207311ef298d3f7b2f7d8f6ac60113071/pydantic_core-2.23.4-cp311-none-win_amd64.whl", hash = "sha256:98d134c954828488b153d88ba1f34e14259284f256180ce659e8d83e9c05eaa3", size = 1916804 }, - { url = "https://files.pythonhosted.org/packages/74/7b/8e315f80666194b354966ec84b7d567da77ad927ed6323db4006cf915f3f/pydantic_core-2.23.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f3e0da4ebaef65158d4dfd7d3678aad692f7666877df0002b8a522cdf088f231", size = 1856459 }, - { url = "https://files.pythonhosted.org/packages/14/de/866bdce10ed808323d437612aca1ec9971b981e1c52e5e42ad9b8e17a6f6/pydantic_core-2.23.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f69a8e0b033b747bb3e36a44e7732f0c99f7edd5cea723d45bc0d6e95377ffee", size = 1770007 }, - { url = "https://files.pythonhosted.org/packages/dc/69/8edd5c3cd48bb833a3f7ef9b81d7666ccddd3c9a635225214e044b6e8281/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723314c1d51722ab28bfcd5240d858512ffd3116449c557a1336cbe3919beb87", size = 1790245 }, - { url = "https://files.pythonhosted.org/packages/80/33/9c24334e3af796ce80d2274940aae38dd4e5676298b4398eff103a79e02d/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb2802e667b7051a1bebbfe93684841cc9351004e2badbd6411bf357ab8d5ac8", size = 1801260 }, - { url = "https://files.pythonhosted.org/packages/a5/6f/e9567fd90104b79b101ca9d120219644d3314962caa7948dd8b965e9f83e/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d18ca8148bebe1b0a382a27a8ee60350091a6ddaf475fa05ef50dc35b5df6327", size = 1996872 }, - { url = "https://files.pythonhosted.org/packages/2d/ad/b5f0fe9e6cfee915dd144edbd10b6e9c9c9c9d7a56b69256d124b8ac682e/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33e3d65a85a2a4a0dc3b092b938a4062b1a05f3a9abde65ea93b233bca0e03f2", size = 2661617 }, - { url = "https://files.pythonhosted.org/packages/06/c8/7d4b708f8d05a5cbfda3243aad468052c6e99de7d0937c9146c24d9f12e9/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:128585782e5bfa515c590ccee4b727fb76925dd04a98864182b22e89a4e6ed36", size = 2071831 }, - { url = "https://files.pythonhosted.org/packages/89/4d/3079d00c47f22c9a9a8220db088b309ad6e600a73d7a69473e3a8e5e3ea3/pydantic_core-2.23.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:68665f4c17edcceecc112dfed5dbe6f92261fb9d6054b47d01bf6371a6196126", size = 1917453 }, - { url = "https://files.pythonhosted.org/packages/e9/88/9df5b7ce880a4703fcc2d76c8c2d8eb9f861f79d0c56f4b8f5f2607ccec8/pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:20152074317d9bed6b7a95ade3b7d6054845d70584216160860425f4fbd5ee9e", size = 1968793 }, - { url = "https://files.pythonhosted.org/packages/e3/b9/41f7efe80f6ce2ed3ee3c2dcfe10ab7adc1172f778cc9659509a79518c43/pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9261d3ce84fa1d38ed649c3638feefeae23d32ba9182963e465d58d62203bd24", size = 2116872 }, - { url = "https://files.pythonhosted.org/packages/63/08/b59b7a92e03dd25554b0436554bf23e7c29abae7cce4b1c459cd92746811/pydantic_core-2.23.4-cp312-none-win32.whl", hash = "sha256:4ba762ed58e8d68657fc1281e9bb72e1c3e79cc5d464be146e260c541ec12d84", size = 1738535 }, - { url = "https://files.pythonhosted.org/packages/88/8d/479293e4d39ab409747926eec4329de5b7129beaedc3786eca070605d07f/pydantic_core-2.23.4-cp312-none-win_amd64.whl", hash = "sha256:97df63000f4fea395b2824da80e169731088656d1818a11b95f3b173747b6cd9", size = 1917992 }, + { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584 }, + { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071 }, + { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823 }, + { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792 }, + { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338 }, + { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998 }, + { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200 }, + { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890 }, + { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359 }, + { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883 }, + { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074 }, + { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538 }, + { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909 }, + { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786 }, + { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000 }, + { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996 }, + { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957 }, + { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199 }, + { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296 }, + { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109 }, + { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028 }, + { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044 }, + { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881 }, + { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034 }, + { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187 }, + { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628 }, + { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866 }, + { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894 }, + { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200 }, + { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123 }, + { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852 }, + { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484 }, + { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896 }, + { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475 }, + { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013 }, + { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715 }, + { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757 }, ] [[package]] name = "pydantic-settings" -version = "2.9.1" +version = "2.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic" }, { name = "python-dotenv" }, { name = "typing-inspection" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/67/1d/42628a2c33e93f8e9acbde0d5d735fa0850f3e6a2f8cb1eb6c40b9a732ac/pydantic_settings-2.9.1.tar.gz", hash = "sha256:c509bf79d27563add44e8446233359004ed85066cd096d8b510f715e6ef5d268", size = 163234 } +sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b6/5f/d6d641b490fd3ec2c4c13b4244d68deea3a1b970a97be64f34fb5504ff72/pydantic_settings-2.9.1-py3-none-any.whl", hash = "sha256:59b4f431b1defb26fe620c71a7d3968a710d719f5f4cdbbdb7926edeb770f6ef", size = 44356 }, + { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235 }, ] [[package]] @@ -3439,126 +2605,26 @@ wheels = [ [[package]] name = "pygments" -version = "2.19.1" +version = "2.19.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 } wheels = [ - { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 }, ] -[[package]] -name = "pylatexenc" -version = "2.10" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5d/ab/34ec41718af73c00119d0351b7a2531d2ebddb51833a36448fc7b862be60/pylatexenc-2.10.tar.gz", hash = "sha256:3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3", size = 162597 } - [[package]] name = "pymupdf" -version = "1.26.1" +version = "1.26.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bd/62/d29612ca33b7844e77d2c789fec359f4c44fd84bdd08ce673f6279d257e9/pymupdf-1.26.1.tar.gz", hash = "sha256:372c77c831f82090ce7a6e4de284ca7c5a78220f63038bb28c5d9b279cd7f4d9", size = 75912371 } +sdist = { url = "https://files.pythonhosted.org/packages/6d/d4/70a265e4bcd43e97480ae62da69396ef4507c8f9cfd179005ee731c92a04/pymupdf-1.26.3.tar.gz", hash = "sha256:b7d2c3ffa9870e1e4416d18862f5ccd356af5fe337b4511093bbbce2ca73b7e5", size = 75990308 } wheels = [ - { url = "https://files.pythonhosted.org/packages/32/5a/3399a2caf51c91db650de57464465b830c2d4ea15b23d24a98182202b704/pymupdf-1.26.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:32296f12a7c7f36febd59cee77823a54490313bcaba9879b17def6518186f94e", size = 23054640 }, - { url = "https://files.pythonhosted.org/packages/64/e0/cc3ec6a4d5ada8992b8610f134565ceb517243f12736b50d795cb3459315/pymupdf-1.26.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:aad7949eca62aca40854510cdb125cf873b181726dc9497a90834200f31faa63", size = 22402766 }, - { url = "https://files.pythonhosted.org/packages/e8/cf/d5b1cd775a17a7b83e25cbf4c46f64cf1352c962ca97646e3e01953cf0df/pymupdf-1.26.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:3b62c4d443121ed9a2eb967c3a0e45f8dbabcc838db8604ece02c4e868808edc", size = 23448474 }, - { url = "https://files.pythonhosted.org/packages/82/9f/e7101bd24a0f5cbfa0310c8e5c3a8ec0dd9a86986812ff86ac2fbd273c92/pymupdf-1.26.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a65c411eb1cbb79e40c307e10fbad23658f19e9d7334ac4de21d24b58009a7b9", size = 24056183 }, - { url = "https://files.pythonhosted.org/packages/99/39/23ac15cf0edc2877ef366dc7ae041ac199d212433c2c3113661d1a1d5ad0/pymupdf-1.26.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:26cebdcc1b2b7a7445423599ce2e0000f2be0333cce0fa0e6846e5a7da46f965", size = 24258802 }, - { url = "https://files.pythonhosted.org/packages/e1/8c/56bd5951128d5c5c0b64d2942090c2cd7bc44302bac991b941ac736e3d63/pymupdf-1.26.1-cp39-abi3-win32.whl", hash = "sha256:82ed9e106cf564fc959c0691c374ba68443086ba1a1c9f26128eebbc3e6df9e5", size = 16927933 }, - { url = "https://files.pythonhosted.org/packages/a7/1b/0613759a059c8c952c18811c7c7dd0ba5d7945ed13a535719489f533d700/pymupdf-1.26.1-cp39-abi3-win_amd64.whl", hash = "sha256:8deae5168fce37d707f68d1981da6c0bb71f1f176d9835d5914ad46f779a036f", size = 18519587 }, -] - -[[package]] -name = "pyparsing" -version = "3.2.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120 }, -] - -[[package]] -name = "pypdfium2" -version = "4.30.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/55/d4/905e621c62598a08168c272b42fc00136c8861cfce97afb2a1ecbd99487a/pypdfium2-4.30.1.tar.gz", hash = "sha256:5f5c7c6d03598e107d974f66b220a49436aceb191da34cda5f692be098a814ce", size = 164854 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/30/8e/3ce0856b3af0f058dd3655ce57d31d1dbde4d4bd0e172022ffbf1b58a4b9/pypdfium2-4.30.1-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:e07c47633732cc18d890bb7e965ad28a9c5a932e548acb928596f86be2e5ae37", size = 2889836 }, - { url = "https://files.pythonhosted.org/packages/c2/6a/f6995b21f9c6c155487ce7df70632a2df1ba49efcb291b9943ea45f28b15/pypdfium2-4.30.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5ea2d44e96d361123b67b00f527017aa9c847c871b5714e013c01c3eb36a79fe", size = 2769232 }, - { url = "https://files.pythonhosted.org/packages/53/91/79060923148e6d380b8a299b32bba46d70aac5fe1cd4f04320bcbd1a48d3/pypdfium2-4.30.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1de7a3a36803171b3f66911131046d65a732f9e7834438191cb58235e6163c4e", size = 2847531 }, - { url = "https://files.pythonhosted.org/packages/a8/6c/93507f87c159e747eaab54352c0fccbaec3f1b3749d0bb9085a47899f898/pypdfium2-4.30.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b8a4231efb13170354f568c722d6540b8d5b476b08825586d48ef70c40d16e03", size = 2636266 }, - { url = "https://files.pythonhosted.org/packages/24/dc/d56f74a092f2091e328d6485f16562e2fc51cffb0ad6d5c616d80c1eb53c/pypdfium2-4.30.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f434a4934e8244aa95343ffcf24e9ad9f120dbb4785f631bb40a88c39292493", size = 2919296 }, - { url = "https://files.pythonhosted.org/packages/be/d9/a2f1ee03d47fbeb48bcfde47ed7155772739622cfadf7135a84ba6a97824/pypdfium2-4.30.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f454032a0bc7681900170f67d8711b3942824531e765f91c2f5ce7937f999794", size = 2866119 }, - { url = "https://files.pythonhosted.org/packages/01/47/6aa019c32aa39d3f33347c458c0c5887e84096cbe444456402bc97e66704/pypdfium2-4.30.1-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:bbf9130a72370ee9d602e39949b902db669a2a1c24746a91e5586eb829055d9f", size = 6228684 }, - { url = "https://files.pythonhosted.org/packages/4c/07/2954c15b3f7c85ceb80cad36757fd41b3aba0dd14e68f4bed9ce3f2e7e74/pypdfium2-4.30.1-py3-none-musllinux_1_1_i686.whl", hash = "sha256:5cb52884b1583b96e94fd78542c63bb42e06df5e8f9e52f8f31f5ad5a1e53367", size = 6231815 }, - { url = "https://files.pythonhosted.org/packages/b4/9b/b4667e95754624f4af5a912001abba90c046e1c80d4a4e887f0af664ffec/pypdfium2-4.30.1-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:1a9e372bd4867ff223cc8c338e33fe11055dad12f22885950fc27646cc8d9122", size = 6313429 }, - { url = "https://files.pythonhosted.org/packages/43/38/f9e77cf55ba5546a39fa659404b78b97de2ca344848271e7731efb0954cd/pypdfium2-4.30.1-py3-none-win32.whl", hash = "sha256:421f1cf205e213e07c1f2934905779547f4f4a2ff2f59dde29da3d511d3fc806", size = 2834989 }, - { url = "https://files.pythonhosted.org/packages/a4/f3/8d3a350efb4286b5ebdabcf6736f51d8e3b10dbe68804c6930b00f5cf329/pypdfium2-4.30.1-py3-none-win_amd64.whl", hash = "sha256:598a7f20264ab5113853cba6d86c4566e4356cad037d7d1f849c8c9021007e05", size = 2960157 }, - { url = "https://files.pythonhosted.org/packages/e1/6b/2706497c86e8d69fb76afe5ea857fe1794621aa0f3b1d863feb953fe0f22/pypdfium2-4.30.1-py3-none-win_arm64.whl", hash = "sha256:c2b6d63f6d425d9416c08d2511822b54b8e3ac38e639fc41164b1d75584b3a8c", size = 2814810 }, -] - -[[package]] -name = "pytest" -version = "8.4.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, - { name = "iniconfig" }, - { name = "packaging" }, - { name = "pluggy" }, - { name = "pygments" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/08/ba/45911d754e8eba3d5a841a5ce61a65a685ff1798421ac054f85aa8747dfb/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c", size = 1517714 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7", size = 365474 }, -] - -[[package]] -name = "pytest-xdist" -version = "3.7.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "execnet" }, - { name = "pytest" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/49/dc/865845cfe987b21658e871d16e0a24e871e00884c545f246dd8f6f69edda/pytest_xdist-3.7.0.tar.gz", hash = "sha256:f9248c99a7c15b7d2f90715df93610353a485827bc06eefb6566d23f6400f126", size = 87550 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/b2/0e802fde6f1c5b2f7ae7e9ad42b83fd4ecebac18a8a8c2f2f14e39dce6e1/pytest_xdist-3.7.0-py3-none-any.whl", hash = "sha256:7d3fbd255998265052435eb9daa4e99b62e6fb9cfb6efd1f858d4d8c0c7f0ca0", size = 46142 }, -] - -[[package]] -name = "python-bidi" -version = "0.6.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c4/de/1822200711beaadb2f334fa25f59ad9c2627de423c103dde7e81aedbc8e2/python_bidi-0.6.6.tar.gz", hash = "sha256:07db4c7da502593bd6e39c07b3a38733704070de0cbf92a7b7277b7be8867dd9", size = 45102 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/03/b10c5c320fa5f3bc3d7736b2268179cc7f4dca4d054cdf2c932532d6b11a/python_bidi-0.6.6-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:da4949496e563b51f53ff34aad5a9f4c3aaf06f4180cf3bcb42bec649486c8f1", size = 269512 }, - { url = "https://files.pythonhosted.org/packages/91/d8/8f6bd8f4662e8340e1aabb3b9a01fb1de24e8d1ce4f38b160f5cac2524f4/python_bidi-0.6.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c48a755ca8ba3f2b242d6795d4a60e83ca580cc4fa270a3aaa8af05d93b7ba7f", size = 264042 }, - { url = "https://files.pythonhosted.org/packages/51/9f/2c831510ab8afb03b5ec4b15271dc547a2e8643563a7bcc712cd43b29d26/python_bidi-0.6.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76a1cd320993ba3e91a567e97f057a03f2c6b493096b3fff8b5630f51a38e7eb", size = 290963 }, - { url = "https://files.pythonhosted.org/packages/95/45/17a76e7052d4d4bc1549ac2061f1fdebbaa9b7448ce81e774b7f77dc70b2/python_bidi-0.6.6-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e8bf3e396f9ebe8f4f81e92fa4c98c50160d60c58964b89c8ff4ee0c482befaa", size = 298639 }, - { url = "https://files.pythonhosted.org/packages/00/11/fb5857168dcc50a2ebb2a5d8771a64b7fc66c19c9586b6f2a4d8a76db2e8/python_bidi-0.6.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a2a49b506ed21f762ebf332de6de689bc4912e24dcc3b85f120b34e5f01e541a", size = 351898 }, - { url = "https://files.pythonhosted.org/packages/18/e7/d25b3e767e204b9e236e7cb042bf709fd5a985cfede8c990da3bbca862a3/python_bidi-0.6.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3428331e7ce0d58c15b5a57e18a43a12e28f8733086066e6fd75b0ded80e1cae", size = 331117 }, - { url = "https://files.pythonhosted.org/packages/75/50/248decd41096b4954c3887fc7fae864b8e1e90d28d1b4ce5a28c087c3d8d/python_bidi-0.6.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:35adfb9fed3e72b9043a5c00b6ab69e4b33d53d2d8f8b9f60d4df700f77bc2c0", size = 292950 }, - { url = "https://files.pythonhosted.org/packages/0b/d8/6ae7827fbba1403882930d4da8cbab28ab6b86b61a381c991074fb5003d1/python_bidi-0.6.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:589c5b24a8c4b5e07a1e97654020734bf16ed01a4353911ab663a37aaf1c281d", size = 307909 }, - { url = "https://files.pythonhosted.org/packages/4c/a3/5b369c5da7b08b36907dcce7a78c730370ad6899459282f5e703ec1964c6/python_bidi-0.6.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:994534e47260d712c3b3291a6ab55b46cdbfd78a879ef95d14b27bceebfd4049", size = 465552 }, - { url = "https://files.pythonhosted.org/packages/82/07/7779668967c0f17a107a916ec7891507b7bcdc9c7ee4d2c4b6a80ba1ac5e/python_bidi-0.6.6-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:00622f54a80826a918b22a2d6d5481bb3f669147e17bac85c81136b6ffbe7c06", size = 557371 }, - { url = "https://files.pythonhosted.org/packages/2d/e5/3154ac009a167bf0811195f12cf5e896c77a29243522b4b0697985881bc4/python_bidi-0.6.6-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:965e6f2182e7b9352f2d79221f6c49502a307a9778d7d87d82dc36bb1ffecbab", size = 485458 }, - { url = "https://files.pythonhosted.org/packages/fd/db/88af6f0048d8ec7281b44b5599a3d2afa18fac5dd22eb72526f28f4ea647/python_bidi-0.6.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:53d7d3a550d176df99dd0bb0cc2da16b40634f11c8b9f5715777441d679c0a62", size = 459588 }, - { url = "https://files.pythonhosted.org/packages/bb/d2/77b649c8b32c2b88e2facf5a42fb51dfdcc9e13db411c8bc84831ad64893/python_bidi-0.6.6-cp311-cp311-win32.whl", hash = "sha256:b271cd05cb40f47eb4600de79a8e47f8579d81ce35f5650b39b7860d018c3ece", size = 155683 }, - { url = "https://files.pythonhosted.org/packages/95/41/d4dbc72b96e2eea3aeb9292707459372c8682ef039cd19fcac7e09d513ef/python_bidi-0.6.6-cp311-cp311-win_amd64.whl", hash = "sha256:4ff1eba0ff87e04bd35d7e164203ad6e5ce19f0bac0bdf673134c0b78d919608", size = 160587 }, - { url = "https://files.pythonhosted.org/packages/6f/84/45484b091e89d657b0edbfc4378d94ae39915e1f230cb13614f355ff7f22/python_bidi-0.6.6-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:166060a31c10aa3ffadd52cf10a3c9c2b8d78d844e0f2c5801e2ed511d3ec316", size = 267218 }, - { url = "https://files.pythonhosted.org/packages/b7/17/b314c260366a8fb370c58b98298f903fb2a3c476267efbe792bb8694ac7c/python_bidi-0.6.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8706addd827840c2c3b3a9963060d9b979b43801cc9be982efa9644facd3ed26", size = 262129 }, - { url = "https://files.pythonhosted.org/packages/27/b6/8212d0f83aaa361ab33f98c156a453ea5cfb9ac40fab06eef9a156ba4dfa/python_bidi-0.6.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69c02316a4f72a168ea6f66b90d845086e2f2d2de6b08eb32c576db36582177c", size = 290811 }, - { url = "https://files.pythonhosted.org/packages/cd/05/cd503307cd478d18f09b301d20e38ef4107526e65e9cbb9ce489cc2ddbf3/python_bidi-0.6.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a525bcb77b8edbfdcf8b199dbed24556e6d1436af8f5fa392f6cdc93ed79b4af", size = 298175 }, - { url = "https://files.pythonhosted.org/packages/e0/0c/bd7bbd70bd330f282c534f03235a9b8da56262ea97a353d8fe9e367d0d7c/python_bidi-0.6.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bb186c8da4bdc953893504bba93f41d5b412fd767ba5661ff606f22950ec609", size = 351470 }, - { url = "https://files.pythonhosted.org/packages/5e/ab/05a1864d5317e69e022930457f198c2d0344fd281117499ad3fedec5b77c/python_bidi-0.6.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:25fa21b46dc80ac7099d2dee424b634eb1f76b2308d518e505a626c55cdbf7b1", size = 329468 }, - { url = "https://files.pythonhosted.org/packages/07/7c/094bbcb97089ac79f112afa762051129c55d52a7f58923203dfc62f75feb/python_bidi-0.6.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b31f5562839e7ecea881ba337f9d39716e2e0e6b3ba395e824620ee5060050ff", size = 292102 }, - { url = "https://files.pythonhosted.org/packages/99/6b/5e2e6c2d76e7669b9dd68227e8e70cf72a6566ffdf414b31b64098406030/python_bidi-0.6.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fb750d3d5ac028e8afd62d000928a2110dbca012fee68b1a325a38caa03dc50b", size = 307282 }, - { url = "https://files.pythonhosted.org/packages/5e/da/6cbe04f605100978755fc5f4d8a8209789b167568e1e08e753d1a88edcc5/python_bidi-0.6.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8b5f648ee8e9f4ac0400f71e671934b39837d7031496e0edde867a303344d758", size = 464487 }, - { url = "https://files.pythonhosted.org/packages/d5/83/d15a0c944b819b8f101418b973772c42fb818c325c82236978db71b1ed7e/python_bidi-0.6.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c4c0255940e6ff98fb05f9d5de3ffcaab7b60d821d4ca072b50c4f871b036562", size = 556449 }, - { url = "https://files.pythonhosted.org/packages/0f/9a/80f0551adcbc9dd02304a4e4ae46113bb1f6f5172831ad86b860814ff498/python_bidi-0.6.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e7e36601edda15e67527560b1c00108b0d27831260b6b251cf7c6dd110645c03", size = 484368 }, - { url = "https://files.pythonhosted.org/packages/9e/05/4a4074530e54a3e384535d185c77fe9bf0321b207bfcb3a9c1676ee9976f/python_bidi-0.6.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:07c9f000671b187319bacebb9e98d8b75005ccd16aa41b9d4411e66813c467bb", size = 458846 }, - { url = "https://files.pythonhosted.org/packages/9f/10/91d112d152b273e54ca7b7d476faaf27e9a350ef85b4fcc281bdd577d13b/python_bidi-0.6.6-cp312-cp312-win32.whl", hash = "sha256:57c0ca449a116c4f804422111b3345281c4e69c733c4556fa216644ec9907078", size = 155236 }, - { url = "https://files.pythonhosted.org/packages/30/da/e1537900bc8a838b0637124cf8f7ef36ce87b5cdc41fb4c26752a4b9c25a/python_bidi-0.6.6-cp312-cp312-win_amd64.whl", hash = "sha256:f60afe457a37bd908fdc7b520c07620b1a7cc006e08b6e3e70474025b4f5e5c7", size = 160251 }, + { url = "https://files.pythonhosted.org/packages/70/d3/c7af70545cd3097a869fd635bb6222108d3a0fb28c0b8254754a126c4cbb/pymupdf-1.26.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ded891963944e5f13b03b88f6d9e982e816a4ec8689fe360876eef000c161f2b", size = 23057205 }, + { url = "https://files.pythonhosted.org/packages/04/3d/ec5b69bfeaa5deefa7141fc0b20d77bb20404507cf17196b4eb59f1f2977/pymupdf-1.26.3-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:436a33c738bb10eadf00395d18a6992b801ffb26521ee1f361ae786dd283327a", size = 22406630 }, + { url = "https://files.pythonhosted.org/packages/fc/20/661d3894bb05ad75ed6ca103ee2c3fa44d88a458b5c8d4a946b9c0f2569b/pymupdf-1.26.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a2d7a3cd442f12f05103cb3bb1415111517f0a97162547a3720f3bbbc5e0b51c", size = 23450287 }, + { url = "https://files.pythonhosted.org/packages/9c/7f/21828f018e65b16a033731d21f7b46d93fa81c6e8257f769ca4a1c2a1cb0/pymupdf-1.26.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:454f38c8cf07eb333eb4646dca10517b6e90f57ce2daa2265a78064109d85555", size = 24057319 }, + { url = "https://files.pythonhosted.org/packages/71/5d/e8f88cd5a45b8f5fa6590ce8cef3ce0fad30eac6aac8aea12406f95bee7d/pymupdf-1.26.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:759b75d2f710ff4edf8d097d2e98f60e9ecef47632cead6f949b3412facdb9f0", size = 24261350 }, + { url = "https://files.pythonhosted.org/packages/82/22/ecc560e4f281b5dffafbf3a81f023d268b1746d028044f495115b74a2e70/pymupdf-1.26.3-cp39-abi3-win32.whl", hash = "sha256:a839ed44742faa1cd4956bb18068fe5aae435d67ce915e901318646c4e7bbea6", size = 17116371 }, + { url = "https://files.pythonhosted.org/packages/4a/26/8c72973b8833a72785cedc3981eb59b8ac7075942718bbb7b69b352cdde4/pymupdf-1.26.3-cp39-abi3-win_amd64.whl", hash = "sha256:b4cd5124d05737944636cf45fc37ce5824f10e707b0342efe109c7b6bd37a9cc", size = 18735124 }, ] [[package]] @@ -3588,23 +2654,11 @@ wheels = [ [[package]] name = "python-dotenv" -version = "1.1.0" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/88/2c/7bb1416c5620485aa793f2de31d3df393d3686aa8a8506d11e10e13c5baf/python_dotenv-1.1.0.tar.gz", hash = "sha256:41f90bc6f5f177fb41f53e87666db362025010eb28f60a01c9143bfa33a2b2d5", size = 39920 } +sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978 } wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/18/98a99ad95133c6a6e2005fe89faedf294a748bd5dc803008059409ac9b1e/python_dotenv-1.1.0-py3-none-any.whl", hash = "sha256:d7c01d9e2293916c18baf562d95698754b0dbbb5e74d457c45d4f6561fb9d55d", size = 20256 }, -] - -[[package]] -name = "python-levenshtein" -version = "0.26.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "levenshtein" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/31/72/58d77cb80b3c130d94f53a8204ffad9acfddb925b2fb5818ff9af0b3c832/python_levenshtein-0.26.1.tar.gz", hash = "sha256:24ba578e28058ebb4afa2700057e1678d7adf27e43cd1f17700c09a9009d5d3a", size = 12276 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0f/d7/03e0453719ed89724664f781f0255949408118093dbf77a2aa2a1198b38e/python_Levenshtein-0.26.1-py3-none-any.whl", hash = "sha256:8ef5e529dd640fb00f05ee62d998d2ee862f19566b641ace775d5ae16167b2ef", size = 9426 }, + { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556 }, ] [[package]] @@ -3642,20 +2696,20 @@ wheels = [ [[package]] name = "pytubefix" -version = "9.2.0" +version = "9.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5f/61/e5ddfe61efd62114a17ce6e4de179dc6ed7f42bd075decbec592ef16fa66/pytubefix-9.2.0.tar.gz", hash = "sha256:40d1979f5873d17953f7d91d82ca0b25dd0182b3cc9d36fa43d8be462636aac1", size = 751615 } +sdist = { url = "https://files.pythonhosted.org/packages/a6/8a/2611bd7297e4b3ee1973c4d78e79f5a416cfebe89d4783f7da6f45c6b5d4/pytubefix-9.3.0.tar.gz", hash = "sha256:bcf7eeb4810f8710d31d6bce071475bd83fbd7ad6c978e32dda9a4802d0b0feb", size = 753289 } wheels = [ - { url = "https://files.pythonhosted.org/packages/80/05/2c806e9b4a997f42756e1aef1d33ea80f8d8844124f79f80ba7bc3b8aae2/pytubefix-9.2.0-py3-none-any.whl", hash = "sha256:06c428a6f28e6e8719bd97036e363151197d1708cd65d508ad1b95f035371a05", size = 758496 }, + { url = "https://files.pythonhosted.org/packages/ac/9d/12e95c594beebe4fcbdddf97e5f571b2af7a2a0da34b6d5f560672d84f8c/pytubefix-9.3.0-py3-none-any.whl", hash = "sha256:97aeb82b4467e3bbf6703aafe618072559cc880dc66c94001b85e5718cf2cf17", size = 760193 }, ] [[package]] name = "pytz" -version = "2025.2" +version = "2024.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884 } +sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 } wheels = [ - { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225 }, + { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 }, ] [[package]] @@ -3733,50 +2787,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/be/8a/4a3764a68abc02e2fbb0668d225b6fda5cd39586dd099cee8b2ed6ab0452/pyzmq-27.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:9df43a2459cd3a3563404c1456b2c4c69564daa7dbaf15724c09821a3329ce46", size = 544726 }, ] -[[package]] -name = "rapidfuzz" -version = "3.13.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ed/f6/6895abc3a3d056b9698da3199b04c0e56226d530ae44a470edabf8b664f0/rapidfuzz-3.13.0.tar.gz", hash = "sha256:d2eaf3839e52cbcc0accbe9817a67b4b0fcf70aaeb229cfddc1c28061f9ce5d8", size = 57904226 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/87/17/9be9eff5a3c7dfc831c2511262082c6786dca2ce21aa8194eef1cb71d67a/rapidfuzz-3.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d395a5cad0c09c7f096433e5fd4224d83b53298d53499945a9b0e5a971a84f3a", size = 1999453 }, - { url = "https://files.pythonhosted.org/packages/75/67/62e57896ecbabe363f027d24cc769d55dd49019e576533ec10e492fcd8a2/rapidfuzz-3.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7b3eda607a019169f7187328a8d1648fb9a90265087f6903d7ee3a8eee01805", size = 1450881 }, - { url = "https://files.pythonhosted.org/packages/96/5c/691c5304857f3476a7b3df99e91efc32428cbe7d25d234e967cc08346c13/rapidfuzz-3.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98e0bfa602e1942d542de077baf15d658bd9d5dcfe9b762aff791724c1c38b70", size = 1422990 }, - { url = "https://files.pythonhosted.org/packages/46/81/7a7e78f977496ee2d613154b86b203d373376bcaae5de7bde92f3ad5a192/rapidfuzz-3.13.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bef86df6d59667d9655905b02770a0c776d2853971c0773767d5ef8077acd624", size = 5342309 }, - { url = "https://files.pythonhosted.org/packages/51/44/12fdd12a76b190fe94bf38d252bb28ddf0ab7a366b943e792803502901a2/rapidfuzz-3.13.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fedd316c165beed6307bf754dee54d3faca2c47e1f3bcbd67595001dfa11e969", size = 1656881 }, - { url = "https://files.pythonhosted.org/packages/27/ae/0d933e660c06fcfb087a0d2492f98322f9348a28b2cc3791a5dbadf6e6fb/rapidfuzz-3.13.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5158da7f2ec02a930be13bac53bb5903527c073c90ee37804090614cab83c29e", size = 1608494 }, - { url = "https://files.pythonhosted.org/packages/3d/2c/4b2f8aafdf9400e5599b6ed2f14bc26ca75f5a923571926ccbc998d4246a/rapidfuzz-3.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b6f913ee4618ddb6d6f3e387b76e8ec2fc5efee313a128809fbd44e65c2bbb2", size = 3072160 }, - { url = "https://files.pythonhosted.org/packages/60/7d/030d68d9a653c301114101c3003b31ce01cf2c3224034cd26105224cd249/rapidfuzz-3.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d25fdbce6459ccbbbf23b4b044f56fbd1158b97ac50994eaae2a1c0baae78301", size = 2491549 }, - { url = "https://files.pythonhosted.org/packages/8e/cd/7040ba538fc6a8ddc8816a05ecf46af9988b46c148ddd7f74fb0fb73d012/rapidfuzz-3.13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:25343ccc589a4579fbde832e6a1e27258bfdd7f2eb0f28cb836d6694ab8591fc", size = 7584142 }, - { url = "https://files.pythonhosted.org/packages/c1/96/85f7536fbceb0aa92c04a1c37a3fc4fcd4e80649e9ed0fb585382df82edc/rapidfuzz-3.13.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a9ad1f37894e3ffb76bbab76256e8a8b789657183870be11aa64e306bb5228fd", size = 2896234 }, - { url = "https://files.pythonhosted.org/packages/55/fd/460e78438e7019f2462fe9d4ecc880577ba340df7974c8a4cfe8d8d029df/rapidfuzz-3.13.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5dc71ef23845bb6b62d194c39a97bb30ff171389c9812d83030c1199f319098c", size = 3437420 }, - { url = "https://files.pythonhosted.org/packages/cc/df/c3c308a106a0993befd140a414c5ea78789d201cf1dfffb8fd9749718d4f/rapidfuzz-3.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b7f4c65facdb94f44be759bbd9b6dda1fa54d0d6169cdf1a209a5ab97d311a75", size = 4410860 }, - { url = "https://files.pythonhosted.org/packages/75/ee/9d4ece247f9b26936cdeaae600e494af587ce9bf8ddc47d88435f05cfd05/rapidfuzz-3.13.0-cp311-cp311-win32.whl", hash = "sha256:b5104b62711565e0ff6deab2a8f5dbf1fbe333c5155abe26d2cfd6f1849b6c87", size = 1843161 }, - { url = "https://files.pythonhosted.org/packages/c9/5a/d00e1f63564050a20279015acb29ecaf41646adfacc6ce2e1e450f7f2633/rapidfuzz-3.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:9093cdeb926deb32a4887ebe6910f57fbcdbc9fbfa52252c10b56ef2efb0289f", size = 1629962 }, - { url = "https://files.pythonhosted.org/packages/3b/74/0a3de18bc2576b794f41ccd07720b623e840fda219ab57091897f2320fdd/rapidfuzz-3.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:f70f646751b6aa9d05be1fb40372f006cc89d6aad54e9d79ae97bd1f5fce5203", size = 866631 }, - { url = "https://files.pythonhosted.org/packages/13/4b/a326f57a4efed8f5505b25102797a58e37ee11d94afd9d9422cb7c76117e/rapidfuzz-3.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a1a6a906ba62f2556372282b1ef37b26bca67e3d2ea957277cfcefc6275cca7", size = 1989501 }, - { url = "https://files.pythonhosted.org/packages/b7/53/1f7eb7ee83a06c400089ec7cb841cbd581c2edd7a4b21eb2f31030b88daa/rapidfuzz-3.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2fd0975e015b05c79a97f38883a11236f5a24cca83aa992bd2558ceaa5652b26", size = 1445379 }, - { url = "https://files.pythonhosted.org/packages/07/09/de8069a4599cc8e6d194e5fa1782c561151dea7d5e2741767137e2a8c1f0/rapidfuzz-3.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d4e13593d298c50c4f94ce453f757b4b398af3fa0fd2fde693c3e51195b7f69", size = 1405986 }, - { url = "https://files.pythonhosted.org/packages/5d/77/d9a90b39c16eca20d70fec4ca377fbe9ea4c0d358c6e4736ab0e0e78aaf6/rapidfuzz-3.13.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed6f416bda1c9133000009d84d9409823eb2358df0950231cc936e4bf784eb97", size = 5310809 }, - { url = "https://files.pythonhosted.org/packages/1e/7d/14da291b0d0f22262d19522afaf63bccf39fc027c981233fb2137a57b71f/rapidfuzz-3.13.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1dc82b6ed01acb536b94a43996a94471a218f4d89f3fdd9185ab496de4b2a981", size = 1629394 }, - { url = "https://files.pythonhosted.org/packages/b7/e4/79ed7e4fa58f37c0f8b7c0a62361f7089b221fe85738ae2dbcfb815e985a/rapidfuzz-3.13.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9d824de871daa6e443b39ff495a884931970d567eb0dfa213d234337343835f", size = 1600544 }, - { url = "https://files.pythonhosted.org/packages/4e/20/e62b4d13ba851b0f36370060025de50a264d625f6b4c32899085ed51f980/rapidfuzz-3.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d18228a2390375cf45726ce1af9d36ff3dc1f11dce9775eae1f1b13ac6ec50f", size = 3052796 }, - { url = "https://files.pythonhosted.org/packages/cd/8d/55fdf4387dec10aa177fe3df8dbb0d5022224d95f48664a21d6b62a5299d/rapidfuzz-3.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9f5fe634c9482ec5d4a6692afb8c45d370ae86755e5f57aa6c50bfe4ca2bdd87", size = 2464016 }, - { url = "https://files.pythonhosted.org/packages/9b/be/0872f6a56c0f473165d3b47d4170fa75263dc5f46985755aa9bf2bbcdea1/rapidfuzz-3.13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:694eb531889f71022b2be86f625a4209c4049e74be9ca836919b9e395d5e33b3", size = 7556725 }, - { url = "https://files.pythonhosted.org/packages/5d/f3/6c0750e484d885a14840c7a150926f425d524982aca989cdda0bb3bdfa57/rapidfuzz-3.13.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11b47b40650e06147dee5e51a9c9ad73bb7b86968b6f7d30e503b9f8dd1292db", size = 2859052 }, - { url = "https://files.pythonhosted.org/packages/6f/98/5a3a14701b5eb330f444f7883c9840b43fb29c575e292e09c90a270a6e07/rapidfuzz-3.13.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:98b8107ff14f5af0243f27d236bcc6e1ef8e7e3b3c25df114e91e3a99572da73", size = 3390219 }, - { url = "https://files.pythonhosted.org/packages/e9/7d/f4642eaaeb474b19974332f2a58471803448be843033e5740965775760a5/rapidfuzz-3.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b836f486dba0aceb2551e838ff3f514a38ee72b015364f739e526d720fdb823a", size = 4377924 }, - { url = "https://files.pythonhosted.org/packages/8e/83/fa33f61796731891c3e045d0cbca4436a5c436a170e7f04d42c2423652c3/rapidfuzz-3.13.0-cp312-cp312-win32.whl", hash = "sha256:4671ee300d1818d7bdfd8fa0608580d7778ba701817216f0c17fb29e6b972514", size = 1823915 }, - { url = "https://files.pythonhosted.org/packages/03/25/5ee7ab6841ca668567d0897905eebc79c76f6297b73bf05957be887e9c74/rapidfuzz-3.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e2065f68fb1d0bf65adc289c1bdc45ba7e464e406b319d67bb54441a1b9da9e", size = 1616985 }, - { url = "https://files.pythonhosted.org/packages/76/5e/3f0fb88db396cb692aefd631e4805854e02120a2382723b90dcae720bcc6/rapidfuzz-3.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:65cc97c2fc2c2fe23586599686f3b1ceeedeca8e598cfcc1b7e56dc8ca7e2aa7", size = 860116 }, - { url = "https://files.pythonhosted.org/packages/88/df/6060c5a9c879b302bd47a73fc012d0db37abf6544c57591bcbc3459673bd/rapidfuzz-3.13.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1ba007f4d35a45ee68656b2eb83b8715e11d0f90e5b9f02d615a8a321ff00c27", size = 1905935 }, - { url = "https://files.pythonhosted.org/packages/a2/6c/a0b819b829e20525ef1bd58fc776fb8d07a0c38d819e63ba2b7c311a2ed4/rapidfuzz-3.13.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d7a217310429b43be95b3b8ad7f8fc41aba341109dc91e978cd7c703f928c58f", size = 1383714 }, - { url = "https://files.pythonhosted.org/packages/6a/c1/3da3466cc8a9bfb9cd345ad221fac311143b6a9664b5af4adb95b5e6ce01/rapidfuzz-3.13.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:558bf526bcd777de32b7885790a95a9548ffdcce68f704a81207be4a286c1095", size = 1367329 }, - { url = "https://files.pythonhosted.org/packages/da/f0/9f2a9043bfc4e66da256b15d728c5fc2d865edf0028824337f5edac36783/rapidfuzz-3.13.0-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:202a87760f5145140d56153b193a797ae9338f7939eb16652dd7ff96f8faf64c", size = 5251057 }, - { url = "https://files.pythonhosted.org/packages/6a/ff/af2cb1d8acf9777d52487af5c6b34ce9d13381a753f991d95ecaca813407/rapidfuzz-3.13.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfcccc08f671646ccb1e413c773bb92e7bba789e3a1796fd49d23c12539fe2e4", size = 2992401 }, - { url = "https://files.pythonhosted.org/packages/c1/c5/c243b05a15a27b946180db0d1e4c999bef3f4221505dff9748f1f6c917be/rapidfuzz-3.13.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:1f219f1e3c3194d7a7de222f54450ce12bc907862ff9a8962d83061c1f923c86", size = 1553782 }, -] - [[package]] name = "readability-lxml" version = "0.8.4.1" @@ -3845,7 +2855,7 @@ wheels = [ [[package]] name = "requests" -version = "2.32.4" +version = "2.32.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "certifi" }, @@ -3853,9 +2863,9 @@ dependencies = [ { name = "idna" }, { name = "urllib3" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258 } +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847 }, + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, ] [[package]] @@ -3885,49 +2895,49 @@ wheels = [ [[package]] name = "rpds-py" -version = "0.25.1" +version = "0.26.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8c/a6/60184b7fc00dd3ca80ac635dd5b8577d444c57e8e8742cecabfacb829921/rpds_py-0.25.1.tar.gz", hash = "sha256:8960b6dac09b62dac26e75d7e2c4a22efb835d827a7278c34f72b2b84fa160e3", size = 27304 } +sdist = { url = "https://files.pythonhosted.org/packages/a5/aa/4456d84bbb54adc6a916fb10c9b374f78ac840337644e4a5eda229c81275/rpds_py-0.26.0.tar.gz", hash = "sha256:20dae58a859b0906f0685642e591056f1e787f3a8b39c8e8749a45dc7d26bdb0", size = 27385 } wheels = [ - { url = "https://files.pythonhosted.org/packages/95/e1/df13fe3ddbbea43567e07437f097863b20c99318ae1f58a0fe389f763738/rpds_py-0.25.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:5f048bbf18b1f9120685c6d6bb70cc1a52c8cc11bdd04e643d28d3be0baf666d", size = 373341 }, - { url = "https://files.pythonhosted.org/packages/7a/58/deef4d30fcbcbfef3b6d82d17c64490d5c94585a2310544ce8e2d3024f83/rpds_py-0.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4fbb0dbba559959fcb5d0735a0f87cdbca9e95dac87982e9b95c0f8f7ad10255", size = 359111 }, - { url = "https://files.pythonhosted.org/packages/bb/7e/39f1f4431b03e96ebaf159e29a0f82a77259d8f38b2dd474721eb3a8ac9b/rpds_py-0.25.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4ca54b9cf9d80b4016a67a0193ebe0bcf29f6b0a96f09db942087e294d3d4c2", size = 386112 }, - { url = "https://files.pythonhosted.org/packages/db/e7/847068a48d63aec2ae695a1646089620b3b03f8ccf9f02c122ebaf778f3c/rpds_py-0.25.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ee3e26eb83d39b886d2cb6e06ea701bba82ef30a0de044d34626ede51ec98b0", size = 400362 }, - { url = "https://files.pythonhosted.org/packages/3b/3d/9441d5db4343d0cee759a7ab4d67420a476cebb032081763de934719727b/rpds_py-0.25.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:89706d0683c73a26f76a5315d893c051324d771196ae8b13e6ffa1ffaf5e574f", size = 522214 }, - { url = "https://files.pythonhosted.org/packages/a2/ec/2cc5b30d95f9f1a432c79c7a2f65d85e52812a8f6cbf8768724571710786/rpds_py-0.25.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c2013ee878c76269c7b557a9a9c042335d732e89d482606990b70a839635feb7", size = 411491 }, - { url = "https://files.pythonhosted.org/packages/dc/6c/44695c1f035077a017dd472b6a3253553780837af2fac9b6ac25f6a5cb4d/rpds_py-0.25.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45e484db65e5380804afbec784522de84fa95e6bb92ef1bd3325d33d13efaebd", size = 386978 }, - { url = "https://files.pythonhosted.org/packages/b1/74/b4357090bb1096db5392157b4e7ed8bb2417dc7799200fcbaee633a032c9/rpds_py-0.25.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:48d64155d02127c249695abb87d39f0faf410733428d499867606be138161d65", size = 420662 }, - { url = "https://files.pythonhosted.org/packages/26/dd/8cadbebf47b96e59dfe8b35868e5c38a42272699324e95ed522da09d3a40/rpds_py-0.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:048893e902132fd6548a2e661fb38bf4896a89eea95ac5816cf443524a85556f", size = 563385 }, - { url = "https://files.pythonhosted.org/packages/c3/ea/92960bb7f0e7a57a5ab233662f12152085c7dc0d5468534c65991a3d48c9/rpds_py-0.25.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0317177b1e8691ab5879f4f33f4b6dc55ad3b344399e23df2e499de7b10a548d", size = 592047 }, - { url = "https://files.pythonhosted.org/packages/61/ad/71aabc93df0d05dabcb4b0c749277881f8e74548582d96aa1bf24379493a/rpds_py-0.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bffcf57826d77a4151962bf1701374e0fc87f536e56ec46f1abdd6a903354042", size = 557863 }, - { url = "https://files.pythonhosted.org/packages/93/0f/89df0067c41f122b90b76f3660028a466eb287cbe38efec3ea70e637ca78/rpds_py-0.25.1-cp311-cp311-win32.whl", hash = "sha256:cda776f1967cb304816173b30994faaf2fd5bcb37e73118a47964a02c348e1bc", size = 219627 }, - { url = "https://files.pythonhosted.org/packages/7c/8d/93b1a4c1baa903d0229374d9e7aa3466d751f1d65e268c52e6039c6e338e/rpds_py-0.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:dc3c1ff0abc91444cd20ec643d0f805df9a3661fcacf9c95000329f3ddf268a4", size = 231603 }, - { url = "https://files.pythonhosted.org/packages/cb/11/392605e5247bead2f23e6888e77229fbd714ac241ebbebb39a1e822c8815/rpds_py-0.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:5a3ddb74b0985c4387719fc536faced33cadf2172769540c62e2a94b7b9be1c4", size = 223967 }, - { url = "https://files.pythonhosted.org/packages/7f/81/28ab0408391b1dc57393653b6a0cf2014cc282cc2909e4615e63e58262be/rpds_py-0.25.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b5ffe453cde61f73fea9430223c81d29e2fbf412a6073951102146c84e19e34c", size = 364647 }, - { url = "https://files.pythonhosted.org/packages/2c/9a/7797f04cad0d5e56310e1238434f71fc6939d0bc517192a18bb99a72a95f/rpds_py-0.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:115874ae5e2fdcfc16b2aedc95b5eef4aebe91b28e7e21951eda8a5dc0d3461b", size = 350454 }, - { url = "https://files.pythonhosted.org/packages/69/3c/93d2ef941b04898011e5d6eaa56a1acf46a3b4c9f4b3ad1bbcbafa0bee1f/rpds_py-0.25.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a714bf6e5e81b0e570d01f56e0c89c6375101b8463999ead3a93a5d2a4af91fa", size = 389665 }, - { url = "https://files.pythonhosted.org/packages/c1/57/ad0e31e928751dde8903a11102559628d24173428a0f85e25e187defb2c1/rpds_py-0.25.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:35634369325906bcd01577da4c19e3b9541a15e99f31e91a02d010816b49bfda", size = 403873 }, - { url = "https://files.pythonhosted.org/packages/16/ad/c0c652fa9bba778b4f54980a02962748479dc09632e1fd34e5282cf2556c/rpds_py-0.25.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d4cb2b3ddc16710548801c6fcc0cfcdeeff9dafbc983f77265877793f2660309", size = 525866 }, - { url = "https://files.pythonhosted.org/packages/2a/39/3e1839bc527e6fcf48d5fec4770070f872cdee6c6fbc9b259932f4e88a38/rpds_py-0.25.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9ceca1cf097ed77e1a51f1dbc8d174d10cb5931c188a4505ff9f3e119dfe519b", size = 416886 }, - { url = "https://files.pythonhosted.org/packages/7a/95/dd6b91cd4560da41df9d7030a038298a67d24f8ca38e150562644c829c48/rpds_py-0.25.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c2cd1a4b0c2b8c5e31ffff50d09f39906fe351389ba143c195566056c13a7ea", size = 390666 }, - { url = "https://files.pythonhosted.org/packages/64/48/1be88a820e7494ce0a15c2d390ccb7c52212370badabf128e6a7bb4cb802/rpds_py-0.25.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1de336a4b164c9188cb23f3703adb74a7623ab32d20090d0e9bf499a2203ad65", size = 425109 }, - { url = "https://files.pythonhosted.org/packages/cf/07/3e2a17927ef6d7720b9949ec1b37d1e963b829ad0387f7af18d923d5cfa5/rpds_py-0.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9fca84a15333e925dd59ce01da0ffe2ffe0d6e5d29a9eeba2148916d1824948c", size = 567244 }, - { url = "https://files.pythonhosted.org/packages/d2/e5/76cf010998deccc4f95305d827847e2eae9c568099c06b405cf96384762b/rpds_py-0.25.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:88ec04afe0c59fa64e2f6ea0dd9657e04fc83e38de90f6de201954b4d4eb59bd", size = 596023 }, - { url = "https://files.pythonhosted.org/packages/52/9a/df55efd84403736ba37a5a6377b70aad0fd1cb469a9109ee8a1e21299a1c/rpds_py-0.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a8bd2f19e312ce3e1d2c635618e8a8d8132892bb746a7cf74780a489f0f6cdcb", size = 561634 }, - { url = "https://files.pythonhosted.org/packages/ab/aa/dc3620dd8db84454aaf9374bd318f1aa02578bba5e567f5bf6b79492aca4/rpds_py-0.25.1-cp312-cp312-win32.whl", hash = "sha256:e5e2f7280d8d0d3ef06f3ec1b4fd598d386cc6f0721e54f09109a8132182fbfe", size = 222713 }, - { url = "https://files.pythonhosted.org/packages/a3/7f/7cef485269a50ed5b4e9bae145f512d2a111ca638ae70cc101f661b4defd/rpds_py-0.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:db58483f71c5db67d643857404da360dce3573031586034b7d59f245144cc192", size = 235280 }, - { url = "https://files.pythonhosted.org/packages/99/f2/c2d64f6564f32af913bf5f3f7ae41c7c263c5ae4c4e8f1a17af8af66cd46/rpds_py-0.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:6d50841c425d16faf3206ddbba44c21aa3310a0cebc3c1cdfc3e3f4f9f6f5728", size = 225399 }, - { url = "https://files.pythonhosted.org/packages/49/74/48f3df0715a585cbf5d34919c9c757a4c92c1a9eba059f2d334e72471f70/rpds_py-0.25.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ee86d81551ec68a5c25373c5643d343150cc54672b5e9a0cafc93c1870a53954", size = 374208 }, - { url = "https://files.pythonhosted.org/packages/55/b0/9b01bb11ce01ec03d05e627249cc2c06039d6aa24ea5a22a39c312167c10/rpds_py-0.25.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89c24300cd4a8e4a51e55c31a8ff3918e6651b241ee8876a42cc2b2a078533ba", size = 359262 }, - { url = "https://files.pythonhosted.org/packages/a9/eb/5395621618f723ebd5116c53282052943a726dba111b49cd2071f785b665/rpds_py-0.25.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:771c16060ff4e79584dc48902a91ba79fd93eade3aa3a12d6d2a4aadaf7d542b", size = 387366 }, - { url = "https://files.pythonhosted.org/packages/68/73/3d51442bdb246db619d75039a50ea1cf8b5b4ee250c3e5cd5c3af5981cd4/rpds_py-0.25.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:785ffacd0ee61c3e60bdfde93baa6d7c10d86f15655bd706c89da08068dc5038", size = 400759 }, - { url = "https://files.pythonhosted.org/packages/b7/4c/3a32d5955d7e6cb117314597bc0f2224efc798428318b13073efe306512a/rpds_py-0.25.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2a40046a529cc15cef88ac5ab589f83f739e2d332cb4d7399072242400ed68c9", size = 523128 }, - { url = "https://files.pythonhosted.org/packages/be/95/1ffccd3b0bb901ae60b1dd4b1be2ab98bb4eb834cd9b15199888f5702f7b/rpds_py-0.25.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:85fc223d9c76cabe5d0bff82214459189720dc135db45f9f66aa7cffbf9ff6c1", size = 411597 }, - { url = "https://files.pythonhosted.org/packages/ef/6d/6e6cd310180689db8b0d2de7f7d1eabf3fb013f239e156ae0d5a1a85c27f/rpds_py-0.25.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b0be9965f93c222fb9b4cc254235b3b2b215796c03ef5ee64f995b1b69af0762", size = 388053 }, - { url = "https://files.pythonhosted.org/packages/4a/87/ec4186b1fe6365ced6fa470960e68fc7804bafbe7c0cf5a36237aa240efa/rpds_py-0.25.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8378fa4a940f3fb509c081e06cb7f7f2adae8cf46ef258b0e0ed7519facd573e", size = 421821 }, - { url = "https://files.pythonhosted.org/packages/7a/60/84f821f6bf4e0e710acc5039d91f8f594fae0d93fc368704920d8971680d/rpds_py-0.25.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:33358883a4490287e67a2c391dfaea4d9359860281db3292b6886bf0be3d8692", size = 564534 }, - { url = "https://files.pythonhosted.org/packages/41/3a/bc654eb15d3b38f9330fe0f545016ba154d89cdabc6177b0295910cd0ebe/rpds_py-0.25.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1d1fadd539298e70cac2f2cb36f5b8a65f742b9b9f1014dd4ea1f7785e2470bf", size = 592674 }, - { url = "https://files.pythonhosted.org/packages/2e/ba/31239736f29e4dfc7a58a45955c5db852864c306131fd6320aea214d5437/rpds_py-0.25.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:9a46c2fb2545e21181445515960006e85d22025bd2fe6db23e76daec6eb689fe", size = 558781 }, + { url = "https://files.pythonhosted.org/packages/09/4c/4ee8f7e512030ff79fda1df3243c88d70fc874634e2dbe5df13ba4210078/rpds_py-0.26.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9e8cb77286025bdb21be2941d64ac6ca016130bfdcd228739e8ab137eb4406ed", size = 372610 }, + { url = "https://files.pythonhosted.org/packages/fa/9d/3dc16be00f14fc1f03c71b1d67c8df98263ab2710a2fbd65a6193214a527/rpds_py-0.26.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5e09330b21d98adc8ccb2dbb9fc6cb434e8908d4c119aeaa772cb1caab5440a0", size = 358032 }, + { url = "https://files.pythonhosted.org/packages/e7/5a/7f1bf8f045da2866324a08ae80af63e64e7bfaf83bd31f865a7b91a58601/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c9c1b92b774b2e68d11193dc39620d62fd8ab33f0a3c77ecdabe19c179cdbc1", size = 381525 }, + { url = "https://files.pythonhosted.org/packages/45/8a/04479398c755a066ace10e3d158866beb600867cacae194c50ffa783abd0/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:824e6d3503ab990d7090768e4dfd9e840837bae057f212ff9f4f05ec6d1975e7", size = 397089 }, + { url = "https://files.pythonhosted.org/packages/72/88/9203f47268db488a1b6d469d69c12201ede776bb728b9d9f29dbfd7df406/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ad7fd2258228bf288f2331f0a6148ad0186b2e3643055ed0db30990e59817a6", size = 514255 }, + { url = "https://files.pythonhosted.org/packages/f5/b4/01ce5d1e853ddf81fbbd4311ab1eff0b3cf162d559288d10fd127e2588b5/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0dc23bbb3e06ec1ea72d515fb572c1fea59695aefbffb106501138762e1e915e", size = 402283 }, + { url = "https://files.pythonhosted.org/packages/34/a2/004c99936997bfc644d590a9defd9e9c93f8286568f9c16cdaf3e14429a7/rpds_py-0.26.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d80bf832ac7b1920ee29a426cdca335f96a2b5caa839811803e999b41ba9030d", size = 383881 }, + { url = "https://files.pythonhosted.org/packages/05/1b/ef5fba4a8f81ce04c427bfd96223f92f05e6cd72291ce9d7523db3b03a6c/rpds_py-0.26.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0919f38f5542c0a87e7b4afcafab6fd2c15386632d249e9a087498571250abe3", size = 415822 }, + { url = "https://files.pythonhosted.org/packages/16/80/5c54195aec456b292f7bd8aa61741c8232964063fd8a75fdde9c1e982328/rpds_py-0.26.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d422b945683e409000c888e384546dbab9009bb92f7c0b456e217988cf316107", size = 558347 }, + { url = "https://files.pythonhosted.org/packages/f2/1c/1845c1b1fd6d827187c43afe1841d91678d7241cbdb5420a4c6de180a538/rpds_py-0.26.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:77a7711fa562ba2da1aa757e11024ad6d93bad6ad7ede5afb9af144623e5f76a", size = 587956 }, + { url = "https://files.pythonhosted.org/packages/2e/ff/9e979329dd131aa73a438c077252ddabd7df6d1a7ad7b9aacf6261f10faa/rpds_py-0.26.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238e8c8610cb7c29460e37184f6799547f7e09e6a9bdbdab4e8edb90986a2318", size = 554363 }, + { url = "https://files.pythonhosted.org/packages/00/8b/d78cfe034b71ffbe72873a136e71acc7a831a03e37771cfe59f33f6de8a2/rpds_py-0.26.0-cp311-cp311-win32.whl", hash = "sha256:893b022bfbdf26d7bedb083efeea624e8550ca6eb98bf7fea30211ce95b9201a", size = 220123 }, + { url = "https://files.pythonhosted.org/packages/94/c1/3c8c94c7dd3905dbfde768381ce98778500a80db9924731d87ddcdb117e9/rpds_py-0.26.0-cp311-cp311-win_amd64.whl", hash = "sha256:87a5531de9f71aceb8af041d72fc4cab4943648d91875ed56d2e629bef6d4c03", size = 231732 }, + { url = "https://files.pythonhosted.org/packages/67/93/e936fbed1b734eabf36ccb5d93c6a2e9246fbb13c1da011624b7286fae3e/rpds_py-0.26.0-cp311-cp311-win_arm64.whl", hash = "sha256:de2713f48c1ad57f89ac25b3cb7daed2156d8e822cf0eca9b96a6f990718cc41", size = 221917 }, + { url = "https://files.pythonhosted.org/packages/ea/86/90eb87c6f87085868bd077c7a9938006eb1ce19ed4d06944a90d3560fce2/rpds_py-0.26.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:894514d47e012e794f1350f076c427d2347ebf82f9b958d554d12819849a369d", size = 363933 }, + { url = "https://files.pythonhosted.org/packages/63/78/4469f24d34636242c924626082b9586f064ada0b5dbb1e9d096ee7a8e0c6/rpds_py-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc921b96fa95a097add244da36a1d9e4f3039160d1d30f1b35837bf108c21136", size = 350447 }, + { url = "https://files.pythonhosted.org/packages/ad/91/c448ed45efdfdade82348d5e7995e15612754826ea640afc20915119734f/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e1157659470aa42a75448b6e943c895be8c70531c43cb78b9ba990778955582", size = 384711 }, + { url = "https://files.pythonhosted.org/packages/ec/43/e5c86fef4be7f49828bdd4ecc8931f0287b1152c0bb0163049b3218740e7/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:521ccf56f45bb3a791182dc6b88ae5f8fa079dd705ee42138c76deb1238e554e", size = 400865 }, + { url = "https://files.pythonhosted.org/packages/55/34/e00f726a4d44f22d5c5fe2e5ddd3ac3d7fd3f74a175607781fbdd06fe375/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9def736773fd56b305c0eef698be5192c77bfa30d55a0e5885f80126c4831a15", size = 517763 }, + { url = "https://files.pythonhosted.org/packages/52/1c/52dc20c31b147af724b16104500fba13e60123ea0334beba7b40e33354b4/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdad4ea3b4513b475e027be79e5a0ceac8ee1c113a1a11e5edc3c30c29f964d8", size = 406651 }, + { url = "https://files.pythonhosted.org/packages/2e/77/87d7bfabfc4e821caa35481a2ff6ae0b73e6a391bb6b343db2c91c2b9844/rpds_py-0.26.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82b165b07f416bdccf5c84546a484cc8f15137ca38325403864bfdf2b5b72f6a", size = 386079 }, + { url = "https://files.pythonhosted.org/packages/e3/d4/7f2200c2d3ee145b65b3cddc4310d51f7da6a26634f3ac87125fd789152a/rpds_py-0.26.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d04cab0a54b9dba4d278fe955a1390da3cf71f57feb78ddc7cb67cbe0bd30323", size = 421379 }, + { url = "https://files.pythonhosted.org/packages/ae/13/9fdd428b9c820869924ab62236b8688b122baa22d23efdd1c566938a39ba/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:79061ba1a11b6a12743a2b0f72a46aa2758613d454aa6ba4f5a265cc48850158", size = 562033 }, + { url = "https://files.pythonhosted.org/packages/f3/e1/b69686c3bcbe775abac3a4c1c30a164a2076d28df7926041f6c0eb5e8d28/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f405c93675d8d4c5ac87364bb38d06c988e11028a64b52a47158a355079661f3", size = 591639 }, + { url = "https://files.pythonhosted.org/packages/5c/c9/1e3d8c8863c84a90197ac577bbc3d796a92502124c27092413426f670990/rpds_py-0.26.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dafd4c44b74aa4bed4b250f1aed165b8ef5de743bcca3b88fc9619b6087093d2", size = 557105 }, + { url = "https://files.pythonhosted.org/packages/9f/c5/90c569649057622959f6dcc40f7b516539608a414dfd54b8d77e3b201ac0/rpds_py-0.26.0-cp312-cp312-win32.whl", hash = "sha256:3da5852aad63fa0c6f836f3359647870e21ea96cf433eb393ffa45263a170d44", size = 223272 }, + { url = "https://files.pythonhosted.org/packages/7d/16/19f5d9f2a556cfed454eebe4d354c38d51c20f3db69e7b4ce6cff904905d/rpds_py-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:cf47cfdabc2194a669dcf7a8dbba62e37a04c5041d2125fae0233b720da6f05c", size = 234995 }, + { url = "https://files.pythonhosted.org/packages/83/f0/7935e40b529c0e752dfaa7880224771b51175fce08b41ab4a92eb2fbdc7f/rpds_py-0.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:20ab1ae4fa534f73647aad289003f1104092890849e0266271351922ed5574f8", size = 223198 }, + { url = "https://files.pythonhosted.org/packages/51/f2/b5c85b758a00c513bb0389f8fc8e61eb5423050c91c958cdd21843faa3e6/rpds_py-0.26.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f61a9326f80ca59214d1cceb0a09bb2ece5b2563d4e0cd37bfd5515c28510674", size = 373505 }, + { url = "https://files.pythonhosted.org/packages/23/e0/25db45e391251118e915e541995bb5f5ac5691a3b98fb233020ba53afc9b/rpds_py-0.26.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:183f857a53bcf4b1b42ef0f57ca553ab56bdd170e49d8091e96c51c3d69ca696", size = 359468 }, + { url = "https://files.pythonhosted.org/packages/0b/73/dd5ee6075bb6491be3a646b301dfd814f9486d924137a5098e61f0487e16/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:941c1cfdf4799d623cf3aa1d326a6b4fdb7a5799ee2687f3516738216d2262fb", size = 382680 }, + { url = "https://files.pythonhosted.org/packages/2f/10/84b522ff58763a5c443f5bcedc1820240e454ce4e620e88520f04589e2ea/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72a8d9564a717ee291f554eeb4bfeafe2309d5ec0aa6c475170bdab0f9ee8e88", size = 397035 }, + { url = "https://files.pythonhosted.org/packages/06/ea/8667604229a10a520fcbf78b30ccc278977dcc0627beb7ea2c96b3becef0/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:511d15193cbe013619dd05414c35a7dedf2088fcee93c6bbb7c77859765bd4e8", size = 514922 }, + { url = "https://files.pythonhosted.org/packages/24/e6/9ed5b625c0661c4882fc8cdf302bf8e96c73c40de99c31e0b95ed37d508c/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aea1f9741b603a8d8fedb0ed5502c2bc0accbc51f43e2ad1337fe7259c2b77a5", size = 402822 }, + { url = "https://files.pythonhosted.org/packages/8a/58/212c7b6fd51946047fb45d3733da27e2fa8f7384a13457c874186af691b1/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4019a9d473c708cf2f16415688ef0b4639e07abaa569d72f74745bbeffafa2c7", size = 384336 }, + { url = "https://files.pythonhosted.org/packages/aa/f5/a40ba78748ae8ebf4934d4b88e77b98497378bc2c24ba55ebe87a4e87057/rpds_py-0.26.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:093d63b4b0f52d98ebae33b8c50900d3d67e0666094b1be7a12fffd7f65de74b", size = 416871 }, + { url = "https://files.pythonhosted.org/packages/d5/a6/33b1fc0c9f7dcfcfc4a4353daa6308b3ece22496ceece348b3e7a7559a09/rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2abe21d8ba64cded53a2a677e149ceb76dcf44284202d737178afe7ba540c1eb", size = 559439 }, + { url = "https://files.pythonhosted.org/packages/71/2d/ceb3f9c12f8cfa56d34995097f6cd99da1325642c60d1b6680dd9df03ed8/rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:4feb7511c29f8442cbbc28149a92093d32e815a28aa2c50d333826ad2a20fdf0", size = 588380 }, + { url = "https://files.pythonhosted.org/packages/c8/ed/9de62c2150ca8e2e5858acf3f4f4d0d180a38feef9fdab4078bea63d8dba/rpds_py-0.26.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e99685fc95d386da368013e7fb4269dd39c30d99f812a8372d62f244f662709c", size = 555334 }, ] [[package]] @@ -3942,161 +2952,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696 }, ] -[[package]] -name = "rtree" -version = "1.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/b8/0091f020acafcb034daa5b062f0626f6a73c7e0d64826af23861390a9585/rtree-1.4.0.tar.gz", hash = "sha256:9d97c7c5dcf25f6c0599c76d9933368c6a8d7238f2c1d00e76f1a69369ca82a0", size = 50789 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f6/4c/8d54d6dc5ff8ba8ced1fad9378f89f9dd60addcc4cf0e525ee0e67b1769f/rtree-1.4.0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:4d1bebc418101480aabf41767e772dd2155d3b27b1376cccbd93e4509485e091", size = 482755 }, - { url = "https://files.pythonhosted.org/packages/20/29/045e700d2135e9a67896086c831fde80fd4105971b443d5727a4093fcbf1/rtree-1.4.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:997f8c38d5dffa3949ea8adb4c8b291ea5cd4ef5ee69455d642dd171baf9991d", size = 439796 }, - { url = "https://files.pythonhosted.org/packages/3d/fc/c3bd8cd67b10a12a6b9e2d06796779128c3e6968922dbf29fcd53af68d81/rtree-1.4.0-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0133d9c54ab3ffe874ba6d411dbe0254765c5e68d92da5b91362c370f16fd997", size = 497549 }, - { url = "https://files.pythonhosted.org/packages/a0/dd/49dc9ab037d0cb288ed40f8b7f498f69d44243e4745e241c05d5e457ea8b/rtree-1.4.0-py3-none-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d3b7bf1fe6463139377995ebe22a01a7005d134707f43672a3c09305e12f5f43", size = 568787 }, - { url = "https://files.pythonhosted.org/packages/fe/e7/57737dff73ce789bdadd916d48ac12e977d8578176e1e890b1b8d89b9dbf/rtree-1.4.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:27e4a6d617d63dcb82fcd4c2856134b8a3741bd1af3b1a0d98e886054f394da5", size = 541090 }, - { url = "https://files.pythonhosted.org/packages/8e/8f/1f3f716c4e8388670cfd5d0a3578e2354a1e6a3403648e234e1540e3e3bd/rtree-1.4.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5258e826064eab82439760201e9421ce6d4340789d6d080c1b49367ddd03f61f", size = 1454194 }, - { url = "https://files.pythonhosted.org/packages/22/ec/b42052b10e63a1c5d5d61ce234332f689736053644ba1756f7a632ea7659/rtree-1.4.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:20d5b3f9cf8bbbcc9fec42ab837c603c5dd86103ef29134300c8da2495c1248b", size = 1692814 }, - { url = "https://files.pythonhosted.org/packages/c5/5b/a9920e9a2dc43b066ff13b7fde2e7bffcca315cfa43ae6f4cc15970e39eb/rtree-1.4.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a67bee1233370a4c72c0969a96d2a1df1ba404ddd9f146849c53ab420eab361b", size = 1554860 }, - { url = "https://files.pythonhosted.org/packages/ce/c2/362f2cc36a7a57b47380061c23fc109c7222c1a544ffd24cda289ba19673/rtree-1.4.0-py3-none-win_amd64.whl", hash = "sha256:ba83efc7b7563905b1bfdfc14490c4bfb59e92e5e6156bdeb6ec5df5117252f4", size = 385221 }, -] - [[package]] name = "ruff" -version = "0.12.0" +version = "0.12.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/24/90/5255432602c0b196a0da6720f6f76b93eb50baef46d3c9b0025e2f9acbf3/ruff-0.12.0.tar.gz", hash = "sha256:4d047db3662418d4a848a3fdbfaf17488b34b62f527ed6f10cb8afd78135bc5c", size = 4376101 } +sdist = { url = "https://files.pythonhosted.org/packages/c3/2a/43955b530c49684d3c38fcda18c43caf91e99204c2a065552528e0552d4f/ruff-0.12.3.tar.gz", hash = "sha256:f1b5a4b6668fd7b7ea3697d8d98857390b40c1320a63a178eee6be0899ea2d77", size = 4459341 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e6/fd/b46bb20e14b11ff49dbc74c61de352e0dc07fb650189513631f6fb5fc69f/ruff-0.12.0-py3-none-linux_armv6l.whl", hash = "sha256:5652a9ecdb308a1754d96a68827755f28d5dfb416b06f60fd9e13f26191a8848", size = 10311554 }, - { url = "https://files.pythonhosted.org/packages/e7/d3/021dde5a988fa3e25d2468d1dadeea0ae89dc4bc67d0140c6e68818a12a1/ruff-0.12.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:05ed0c914fabc602fc1f3b42c53aa219e5736cb030cdd85640c32dbc73da74a6", size = 11118435 }, - { url = "https://files.pythonhosted.org/packages/07/a2/01a5acf495265c667686ec418f19fd5c32bcc326d4c79ac28824aecd6a32/ruff-0.12.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:07a7aa9b69ac3fcfda3c507916d5d1bca10821fe3797d46bad10f2c6de1edda0", size = 10466010 }, - { url = "https://files.pythonhosted.org/packages/4c/57/7caf31dd947d72e7aa06c60ecb19c135cad871a0a8a251723088132ce801/ruff-0.12.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e7731c3eec50af71597243bace7ec6104616ca56dda2b99c89935fe926bdcd48", size = 10661366 }, - { url = "https://files.pythonhosted.org/packages/e9/ba/aa393b972a782b4bc9ea121e0e358a18981980856190d7d2b6187f63e03a/ruff-0.12.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:952d0630eae628250ab1c70a7fffb641b03e6b4a2d3f3ec6c1d19b4ab6c6c807", size = 10173492 }, - { url = "https://files.pythonhosted.org/packages/d7/50/9349ee777614bc3062fc6b038503a59b2034d09dd259daf8192f56c06720/ruff-0.12.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c021f04ea06966b02614d442e94071781c424ab8e02ec7af2f037b4c1e01cc82", size = 11761739 }, - { url = "https://files.pythonhosted.org/packages/04/8f/ad459de67c70ec112e2ba7206841c8f4eb340a03ee6a5cabc159fe558b8e/ruff-0.12.0-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d235618283718ee2fe14db07f954f9b2423700919dc688eacf3f8797a11315c", size = 12537098 }, - { url = "https://files.pythonhosted.org/packages/ed/50/15ad9c80ebd3c4819f5bd8883e57329f538704ed57bac680d95cb6627527/ruff-0.12.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0c0758038f81beec8cc52ca22de9685b8ae7f7cc18c013ec2050012862cc9165", size = 12154122 }, - { url = "https://files.pythonhosted.org/packages/76/e6/79b91e41bc8cc3e78ee95c87093c6cacfa275c786e53c9b11b9358026b3d/ruff-0.12.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:139b3d28027987b78fc8d6cfb61165447bdf3740e650b7c480744873688808c2", size = 11363374 }, - { url = "https://files.pythonhosted.org/packages/db/c3/82b292ff8a561850934549aa9dc39e2c4e783ab3c21debe55a495ddf7827/ruff-0.12.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68853e8517b17bba004152aebd9dd77d5213e503a5f2789395b25f26acac0da4", size = 11587647 }, - { url = "https://files.pythonhosted.org/packages/2b/42/d5760d742669f285909de1bbf50289baccb647b53e99b8a3b4f7ce1b2001/ruff-0.12.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3a9512af224b9ac4757f7010843771da6b2b0935a9e5e76bb407caa901a1a514", size = 10527284 }, - { url = "https://files.pythonhosted.org/packages/19/f6/fcee9935f25a8a8bba4adbae62495c39ef281256693962c2159e8b284c5f/ruff-0.12.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b08df3d96db798e5beb488d4df03011874aff919a97dcc2dd8539bb2be5d6a88", size = 10158609 }, - { url = "https://files.pythonhosted.org/packages/37/fb/057febf0eea07b9384787bfe197e8b3384aa05faa0d6bd844b94ceb29945/ruff-0.12.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6a315992297a7435a66259073681bb0d8647a826b7a6de45c6934b2ca3a9ed51", size = 11141462 }, - { url = "https://files.pythonhosted.org/packages/10/7c/1be8571011585914b9d23c95b15d07eec2d2303e94a03df58294bc9274d4/ruff-0.12.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1e55e44e770e061f55a7dbc6e9aed47feea07731d809a3710feda2262d2d4d8a", size = 11641616 }, - { url = "https://files.pythonhosted.org/packages/6a/ef/b960ab4818f90ff59e571d03c3f992828d4683561095e80f9ef31f3d58b7/ruff-0.12.0-py3-none-win32.whl", hash = "sha256:7162a4c816f8d1555eb195c46ae0bd819834d2a3f18f98cc63819a7b46f474fb", size = 10525289 }, - { url = "https://files.pythonhosted.org/packages/34/93/8b16034d493ef958a500f17cda3496c63a537ce9d5a6479feec9558f1695/ruff-0.12.0-py3-none-win_amd64.whl", hash = "sha256:d00b7a157b8fb6d3827b49d3324da34a1e3f93492c1f97b08e222ad7e9b291e0", size = 11598311 }, - { url = "https://files.pythonhosted.org/packages/d0/33/4d3e79e4a84533d6cd526bfb42c020a23256ae5e4265d858bd1287831f7d/ruff-0.12.0-py3-none-win_arm64.whl", hash = "sha256:8cd24580405ad8c1cc64d61725bca091d6b6da7eb3d36f72cc605467069d7e8b", size = 10724946 }, -] - -[[package]] -name = "safetensors" -version = "0.5.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/71/7e/2d5d6ee7b40c0682315367ec7475693d110f512922d582fef1bd4a63adc3/safetensors-0.5.3.tar.gz", hash = "sha256:b6b0d6ecacec39a4fdd99cc19f4576f5219ce858e6fd8dbe7609df0b8dc56965", size = 67210 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/18/ae/88f6c49dbd0cc4da0e08610019a3c78a7d390879a919411a410a1876d03a/safetensors-0.5.3-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:bd20eb133db8ed15b40110b7c00c6df51655a2998132193de2f75f72d99c7073", size = 436917 }, - { url = "https://files.pythonhosted.org/packages/b8/3b/11f1b4a2f5d2ab7da34ecc062b0bc301f2be024d110a6466726bec8c055c/safetensors-0.5.3-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:21d01c14ff6c415c485616b8b0bf961c46b3b343ca59110d38d744e577f9cce7", size = 418419 }, - { url = "https://files.pythonhosted.org/packages/5d/9a/add3e6fef267658075c5a41573c26d42d80c935cdc992384dfae435feaef/safetensors-0.5.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:11bce6164887cd491ca75c2326a113ba934be596e22b28b1742ce27b1d076467", size = 459493 }, - { url = "https://files.pythonhosted.org/packages/df/5c/bf2cae92222513cc23b3ff85c4a1bb2811a2c3583ac0f8e8d502751de934/safetensors-0.5.3-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4a243be3590bc3301c821da7a18d87224ef35cbd3e5f5727e4e0728b8172411e", size = 472400 }, - { url = "https://files.pythonhosted.org/packages/58/11/7456afb740bd45782d0f4c8e8e1bb9e572f1bf82899fb6ace58af47b4282/safetensors-0.5.3-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8bd84b12b1670a6f8e50f01e28156422a2bc07fb16fc4e98bded13039d688a0d", size = 522891 }, - { url = "https://files.pythonhosted.org/packages/57/3d/fe73a9d2ace487e7285f6e157afee2383bd1ddb911b7cb44a55cf812eae3/safetensors-0.5.3-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:391ac8cab7c829452175f871fcaf414aa1e292b5448bd02620f675a7f3e7abb9", size = 537694 }, - { url = "https://files.pythonhosted.org/packages/a6/f8/dae3421624fcc87a89d42e1898a798bc7ff72c61f38973a65d60df8f124c/safetensors-0.5.3-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cead1fa41fc54b1e61089fa57452e8834f798cb1dc7a09ba3524f1eb08e0317a", size = 471642 }, - { url = "https://files.pythonhosted.org/packages/ce/20/1fbe16f9b815f6c5a672f5b760951e20e17e43f67f231428f871909a37f6/safetensors-0.5.3-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1077f3e94182d72618357b04b5ced540ceb71c8a813d3319f1aba448e68a770d", size = 502241 }, - { url = "https://files.pythonhosted.org/packages/5f/18/8e108846b506487aa4629fe4116b27db65c3dde922de2c8e0cc1133f3f29/safetensors-0.5.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:799021e78287bac619c7b3f3606730a22da4cda27759ddf55d37c8db7511c74b", size = 638001 }, - { url = "https://files.pythonhosted.org/packages/82/5a/c116111d8291af6c8c8a8b40628fe833b9db97d8141c2a82359d14d9e078/safetensors-0.5.3-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df26da01aaac504334644e1b7642fa000bfec820e7cef83aeac4e355e03195ff", size = 734013 }, - { url = "https://files.pythonhosted.org/packages/7d/ff/41fcc4d3b7de837963622e8610d998710705bbde9a8a17221d85e5d0baad/safetensors-0.5.3-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:32c3ef2d7af8b9f52ff685ed0bc43913cdcde135089ae322ee576de93eae5135", size = 670687 }, - { url = "https://files.pythonhosted.org/packages/40/ad/2b113098e69c985a3d8fbda4b902778eae4a35b7d5188859b4a63d30c161/safetensors-0.5.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:37f1521be045e56fc2b54c606d4455573e717b2d887c579ee1dbba5f868ece04", size = 643147 }, - { url = "https://files.pythonhosted.org/packages/0a/0c/95aeb51d4246bd9a3242d3d8349c1112b4ee7611a4b40f0c5c93b05f001d/safetensors-0.5.3-cp38-abi3-win32.whl", hash = "sha256:cfc0ec0846dcf6763b0ed3d1846ff36008c6e7290683b61616c4b040f6a54ace", size = 296677 }, - { url = "https://files.pythonhosted.org/packages/69/e2/b011c38e5394c4c18fb5500778a55ec43ad6106126e74723ffaee246f56e/safetensors-0.5.3-cp38-abi3-win_amd64.whl", hash = "sha256:836cbbc320b47e80acd40e44c8682db0e8ad7123209f69b093def21ec7cafd11", size = 308878 }, -] - -[package.optional-dependencies] -torch = [ - { name = "numpy" }, - { name = "torch" }, -] - -[[package]] -name = "scikit-image" -version = "0.25.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "imageio" }, - { name = "lazy-loader" }, - { name = "networkx" }, - { name = "numpy" }, - { name = "packaging" }, - { name = "pillow" }, - { name = "scipy" }, - { name = "tifffile" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c7/a8/3c0f256012b93dd2cb6fda9245e9f4bff7dc0486880b248005f15ea2255e/scikit_image-0.25.2.tar.gz", hash = "sha256:e5a37e6cd4d0c018a7a55b9d601357e3382826d3888c10d0213fc63bff977dde", size = 22693594 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c4/97/3051c68b782ee3f1fb7f8f5bb7d535cf8cb92e8aae18fa9c1cdf7e15150d/scikit_image-0.25.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f4bac9196fb80d37567316581c6060763b0f4893d3aca34a9ede3825bc035b17", size = 14003057 }, - { url = "https://files.pythonhosted.org/packages/19/23/257fc696c562639826065514d551b7b9b969520bd902c3a8e2fcff5b9e17/scikit_image-0.25.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:d989d64ff92e0c6c0f2018c7495a5b20e2451839299a018e0e5108b2680f71e0", size = 13180335 }, - { url = "https://files.pythonhosted.org/packages/ef/14/0c4a02cb27ca8b1e836886b9ec7c9149de03053650e9e2ed0625f248dd92/scikit_image-0.25.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2cfc96b27afe9a05bc92f8c6235321d3a66499995675b27415e0d0c76625173", size = 14144783 }, - { url = "https://files.pythonhosted.org/packages/dd/9b/9fb556463a34d9842491d72a421942c8baff4281025859c84fcdb5e7e602/scikit_image-0.25.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24cc986e1f4187a12aa319f777b36008764e856e5013666a4a83f8df083c2641", size = 14785376 }, - { url = "https://files.pythonhosted.org/packages/de/ec/b57c500ee85885df5f2188f8bb70398481393a69de44a00d6f1d055f103c/scikit_image-0.25.2-cp311-cp311-win_amd64.whl", hash = "sha256:b4f6b61fc2db6340696afe3db6b26e0356911529f5f6aee8c322aa5157490c9b", size = 12791698 }, - { url = "https://files.pythonhosted.org/packages/35/8c/5df82881284459f6eec796a5ac2a0a304bb3384eec2e73f35cfdfcfbf20c/scikit_image-0.25.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8db8dd03663112783221bf01ccfc9512d1cc50ac9b5b0fe8f4023967564719fb", size = 13986000 }, - { url = "https://files.pythonhosted.org/packages/ce/e6/93bebe1abcdce9513ffec01d8af02528b4c41fb3c1e46336d70b9ed4ef0d/scikit_image-0.25.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:483bd8cc10c3d8a7a37fae36dfa5b21e239bd4ee121d91cad1f81bba10cfb0ed", size = 13235893 }, - { url = "https://files.pythonhosted.org/packages/53/4b/eda616e33f67129e5979a9eb33c710013caa3aa8a921991e6cc0b22cea33/scikit_image-0.25.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d1e80107bcf2bf1291acfc0bf0425dceb8890abe9f38d8e94e23497cbf7ee0d", size = 14178389 }, - { url = "https://files.pythonhosted.org/packages/6b/b5/b75527c0f9532dd8a93e8e7cd8e62e547b9f207d4c11e24f0006e8646b36/scikit_image-0.25.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a17e17eb8562660cc0d31bb55643a4da996a81944b82c54805c91b3fe66f4824", size = 15003435 }, - { url = "https://files.pythonhosted.org/packages/34/e3/49beb08ebccda3c21e871b607c1cb2f258c3fa0d2f609fed0a5ba741b92d/scikit_image-0.25.2-cp312-cp312-win_amd64.whl", hash = "sha256:bdd2b8c1de0849964dbc54037f36b4e9420157e67e45a8709a80d727f52c7da2", size = 12899474 }, -] - -[[package]] -name = "scipy" -version = "1.15.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255 }, - { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035 }, - { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499 }, - { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602 }, - { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415 }, - { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622 }, - { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796 }, - { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684 }, - { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504 }, - { url = "https://files.pythonhosted.org/packages/37/4b/683aa044c4162e10ed7a7ea30527f2cbd92e6999c10a8ed8edb253836e9c/scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019", size = 38766735 }, - { url = "https://files.pythonhosted.org/packages/7b/7e/f30be3d03de07f25dc0ec926d1681fed5c732d759ac8f51079708c79e680/scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6", size = 30173284 }, - { url = "https://files.pythonhosted.org/packages/07/9c/0ddb0d0abdabe0d181c1793db51f02cd59e4901da6f9f7848e1f96759f0d/scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477", size = 22446958 }, - { url = "https://files.pythonhosted.org/packages/af/43/0bce905a965f36c58ff80d8bea33f1f9351b05fad4beaad4eae34699b7a1/scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c", size = 25242454 }, - { url = "https://files.pythonhosted.org/packages/56/30/a6f08f84ee5b7b28b4c597aca4cbe545535c39fe911845a96414700b64ba/scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45", size = 35210199 }, - { url = "https://files.pythonhosted.org/packages/0b/1f/03f52c282437a168ee2c7c14a1a0d0781a9a4a8962d84ac05c06b4c5b555/scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49", size = 37309455 }, - { url = "https://files.pythonhosted.org/packages/89/b1/fbb53137f42c4bf630b1ffdfc2151a62d1d1b903b249f030d2b1c0280af8/scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e", size = 36885140 }, - { url = "https://files.pythonhosted.org/packages/2e/2e/025e39e339f5090df1ff266d021892694dbb7e63568edcfe43f892fa381d/scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539", size = 39710549 }, - { url = "https://files.pythonhosted.org/packages/e6/eb/3bf6ea8ab7f1503dca3a10df2e4b9c3f6b3316df07f6c0ded94b281c7101/scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed", size = 40966184 }, -] - -[[package]] -name = "sdblpy" -version = "0.3.0" -source = { git = "https://github.com/lfnovo/surreal-lite-py#30c250ade7ae9a8dca17f8114a1a05a4c6ce19e1" } -dependencies = [ - { name = "websockets" }, -] - -[[package]] -name = "semchunk" -version = "2.2.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mpire", extra = ["dill"] }, - { name = "tqdm" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/62/96/c418c322730b385e81d4ab462e68dd48bb2dbda4d8efa17cad2ca468d9ac/semchunk-2.2.2.tar.gz", hash = "sha256:940e89896e64eeb01de97ba60f51c8c7b96c6a3951dfcf574f25ce2146752f52", size = 12271 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/76/84/94ca7896c7df20032bcb09973e9a4d14c222507c0aadf22e89fa76bb0a04/semchunk-2.2.2-py3-none-any.whl", hash = "sha256:94ca19020c013c073abdfd06d79a7c13637b91738335f3b8cdb5655ee7cc94d2", size = 10271 }, -] - -[[package]] -name = "setuptools" -version = "75.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/df/ec5ad16b0ec305081c372bd0550fd638fa96e472cd5a03049c344076ea76/setuptools-75.9.1.tar.gz", hash = "sha256:b6eca2c3070cdc82f71b4cb4bb2946bc0760a210d11362278cf1ff394e6ea32c", size = 1345088 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8d/28/19ad82a0549d73ec6feffa6711eacf9246035a9426b8a8b528440c9959d2/setuptools-75.9.1-py3-none-any.whl", hash = "sha256:0a6f876d62f4d978ca1a11ab4daf728d1357731f978543ff18ecdbf9fd071f73", size = 1231632 }, + { url = "https://files.pythonhosted.org/packages/e2/fd/b44c5115539de0d598d75232a1cc7201430b6891808df111b8b0506aae43/ruff-0.12.3-py3-none-linux_armv6l.whl", hash = "sha256:47552138f7206454eaf0c4fe827e546e9ddac62c2a3d2585ca54d29a890137a2", size = 10430499 }, + { url = "https://files.pythonhosted.org/packages/43/c5/9eba4f337970d7f639a37077be067e4ec80a2ad359e4cc6c5b56805cbc66/ruff-0.12.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0a9153b000c6fe169bb307f5bd1b691221c4286c133407b8827c406a55282041", size = 11213413 }, + { url = "https://files.pythonhosted.org/packages/e2/2c/fac3016236cf1fe0bdc8e5de4f24c76ce53c6dd9b5f350d902549b7719b2/ruff-0.12.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fa6b24600cf3b750e48ddb6057e901dd5b9aa426e316addb2a1af185a7509882", size = 10586941 }, + { url = "https://files.pythonhosted.org/packages/c5/0f/41fec224e9dfa49a139f0b402ad6f5d53696ba1800e0f77b279d55210ca9/ruff-0.12.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2506961bf6ead54887ba3562604d69cb430f59b42133d36976421bc8bd45901", size = 10783001 }, + { url = "https://files.pythonhosted.org/packages/0d/ca/dd64a9ce56d9ed6cad109606ac014860b1c217c883e93bf61536400ba107/ruff-0.12.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c4faaff1f90cea9d3033cbbcdf1acf5d7fb11d8180758feb31337391691f3df0", size = 10269641 }, + { url = "https://files.pythonhosted.org/packages/63/5c/2be545034c6bd5ce5bb740ced3e7014d7916f4c445974be11d2a406d5088/ruff-0.12.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40dced4a79d7c264389de1c59467d5d5cefd79e7e06d1dfa2c75497b5269a5a6", size = 11875059 }, + { url = "https://files.pythonhosted.org/packages/8e/d4/a74ef1e801ceb5855e9527dae105eaff136afcb9cc4d2056d44feb0e4792/ruff-0.12.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:0262d50ba2767ed0fe212aa7e62112a1dcbfd46b858c5bf7bbd11f326998bafc", size = 12658890 }, + { url = "https://files.pythonhosted.org/packages/13/c8/1057916416de02e6d7c9bcd550868a49b72df94e3cca0aeb77457dcd9644/ruff-0.12.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12371aec33e1a3758597c5c631bae9a5286f3c963bdfb4d17acdd2d395406687", size = 12232008 }, + { url = "https://files.pythonhosted.org/packages/f5/59/4f7c130cc25220392051fadfe15f63ed70001487eca21d1796db46cbcc04/ruff-0.12.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:560f13b6baa49785665276c963edc363f8ad4b4fc910a883e2625bdb14a83a9e", size = 11499096 }, + { url = "https://files.pythonhosted.org/packages/d4/01/a0ad24a5d2ed6be03a312e30d32d4e3904bfdbc1cdbe63c47be9d0e82c79/ruff-0.12.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:023040a3499f6f974ae9091bcdd0385dd9e9eb4942f231c23c57708147b06311", size = 11688307 }, + { url = "https://files.pythonhosted.org/packages/93/72/08f9e826085b1f57c9a0226e48acb27643ff19b61516a34c6cab9d6ff3fa/ruff-0.12.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:883d844967bffff5ab28bba1a4d246c1a1b2933f48cb9840f3fdc5111c603b07", size = 10661020 }, + { url = "https://files.pythonhosted.org/packages/80/a0/68da1250d12893466c78e54b4a0ff381370a33d848804bb51279367fc688/ruff-0.12.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2120d3aa855ff385e0e562fdee14d564c9675edbe41625c87eeab744a7830d12", size = 10246300 }, + { url = "https://files.pythonhosted.org/packages/6a/22/5f0093d556403e04b6fd0984fc0fb32fbb6f6ce116828fd54306a946f444/ruff-0.12.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6b16647cbb470eaf4750d27dddc6ebf7758b918887b56d39e9c22cce2049082b", size = 11263119 }, + { url = "https://files.pythonhosted.org/packages/92/c9/f4c0b69bdaffb9968ba40dd5fa7df354ae0c73d01f988601d8fac0c639b1/ruff-0.12.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e1417051edb436230023575b149e8ff843a324557fe0a265863b7602df86722f", size = 11746990 }, + { url = "https://files.pythonhosted.org/packages/fe/84/7cc7bd73924ee6be4724be0db5414a4a2ed82d06b30827342315a1be9e9c/ruff-0.12.3-py3-none-win32.whl", hash = "sha256:dfd45e6e926deb6409d0616078a666ebce93e55e07f0fb0228d4b2608b2c248d", size = 10589263 }, + { url = "https://files.pythonhosted.org/packages/07/87/c070f5f027bd81f3efee7d14cb4d84067ecf67a3a8efb43aadfc72aa79a6/ruff-0.12.3-py3-none-win_amd64.whl", hash = "sha256:a946cf1e7ba3209bdef039eb97647f1c77f6f540e5845ec9c114d3af8df873e7", size = 11695072 }, + { url = "https://files.pythonhosted.org/packages/e0/30/f3eaf6563c637b6e66238ed6535f6775480db973c836336e4122161986fc/ruff-0.12.3-py3-none-win_arm64.whl", hash = "sha256:5f9c7c9c8f84c2d7f27e93674d27136fbf489720251544c4da7fb3d742e011b1", size = 10805855 }, ] [[package]] @@ -4162,15 +3040,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, ] -[[package]] -name = "snowballstemmer" -version = "3.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274 }, -] - [[package]] name = "socksio" version = "1.0.0" @@ -4189,125 +3058,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677 }, ] -[[package]] -name = "sphinx" -version = "8.1.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "alabaster" }, - { name = "babel" }, - { name = "colorama", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux' and sys_platform == 'win32') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'win32')" }, - { name = "docutils" }, - { name = "imagesize" }, - { name = "jinja2" }, - { name = "packaging" }, - { name = "pygments" }, - { name = "requests" }, - { name = "snowballstemmer" }, - { name = "sphinxcontrib-applehelp" }, - { name = "sphinxcontrib-devhelp" }, - { name = "sphinxcontrib-htmlhelp" }, - { name = "sphinxcontrib-jsmath" }, - { name = "sphinxcontrib-qthelp" }, - { name = "sphinxcontrib-serializinghtml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125 }, -] - -[[package]] -name = "sphinx-autodoc-typehints" -version = "2.5.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "sphinx" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2e/a0/4f17d564c86aa269749d99dd498a5c94abe0915d2ff349187f8ff8c75994/sphinx_autodoc_typehints-2.5.0.tar.gz", hash = "sha256:259e1026b218d563d72743f417fcc25906a9614897fe37f91bd8d7d58f748c3b", size = 40822 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fa/ae/322d05bec884977b89eced3af811c228652a9e25f9646ee6236890987214/sphinx_autodoc_typehints-2.5.0-py3-none-any.whl", hash = "sha256:53def4753239683835b19bfa8b68c021388bd48a096efcb02cdab508ece27363", size = 20104 }, -] - -[[package]] -name = "sphinx-rtd-theme" -version = "3.0.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "docutils" }, - { name = "sphinx" }, - { name = "sphinxcontrib-jquery" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/91/44/c97faec644d29a5ceddd3020ae2edffa69e7d00054a8c7a6021e82f20335/sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85", size = 7620463 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/85/77/46e3bac77b82b4df5bb5b61f2de98637724f246b4966cfc34bc5895d852a/sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13", size = 7655561 }, -] - -[[package]] -name = "sphinxcontrib-applehelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300 }, -] - -[[package]] -name = "sphinxcontrib-devhelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530 }, -] - -[[package]] -name = "sphinxcontrib-htmlhelp" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705 }, -] - -[[package]] -name = "sphinxcontrib-jquery" -version = "4.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "sphinx" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/de/f3/aa67467e051df70a6330fe7770894b3e4f09436dea6881ae0b4f3d87cad8/sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a", size = 122331 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", size = 121104 }, -] - -[[package]] -name = "sphinxcontrib-jsmath" -version = "1.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071 }, -] - -[[package]] -name = "sphinxcontrib-qthelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743 }, -] - -[[package]] -name = "sphinxcontrib-serializinghtml" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072 }, -] - [[package]] name = "sqlalchemy" version = "2.0.41" @@ -4363,9 +3113,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, ] +[[package]] +name = "starlette" +version = "0.47.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/69/662169fdb92fb96ec3eaee218cf540a629d629c86d7993d9651226a6789b/starlette-0.47.1.tar.gz", hash = "sha256:aef012dd2b6be325ffa16698f9dc533614fb1cebd593a906b90dc1025529a79b", size = 2583072 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/95/38ef0cd7fa11eaba6a99b3c4f5ac948d8bc6ff199aabd327a29cc000840c/starlette-0.47.1-py3-none-any.whl", hash = "sha256:5e11c9f5c7c3f24959edbf2dffdc01bba860228acf657129467d8a7468591527", size = 72747 }, +] + [[package]] name = "streamlit" -version = "1.46.0" +version = "1.46.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "altair" }, @@ -4387,9 +3150,9 @@ dependencies = [ { name = "typing-extensions" }, { name = "watchdog", marker = "platform_system != 'Darwin'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/72/83/f2aac961479594d1d7ee42cf485e3674992769d506732005cea91e11504a/streamlit-1.46.0.tar.gz", hash = "sha256:0b2734b48f11f1e5c8046011b6b1a2274982dc657eef2ade8db70f0e1dc53dda", size = 9651454 } +sdist = { url = "https://files.pythonhosted.org/packages/bd/7e/c7499c447b7021657fa5c851091072c1c7a26f1dda0369c21c0243fc35e7/streamlit-1.46.1.tar.gz", hash = "sha256:2cc4ad01cfeded9ad953a21829eb879b90aa77af4068c68397411c2d5c8862cf", size = 9651018 } wheels = [ - { url = "https://files.pythonhosted.org/packages/be/26/79bbb77bec3d605f7de7a4b45c806b44d112e8c9bce77fb620e03d9f2b88/streamlit-1.46.0-py3-none-any.whl", hash = "sha256:f8624acabafcf18611a0fac2635cf181a7ba922b45bd131ae15fc8f80e1a5482", size = 10050930 }, + { url = "https://files.pythonhosted.org/packages/84/3b/35400175788cdd6a43c90dce1e7f567eb6843a3ba0612508c0f19ee31f5f/streamlit-1.46.1-py3-none-any.whl", hash = "sha256:dffa373230965f87ccc156abaff848d7d731920cf14106f3b99b1ea18076f728", size = 10051346 }, ] [[package]] @@ -4429,24 +3192,54 @@ wheels = [ ] [[package]] -name = "sympy" -version = "1.14.0" +name = "surreal-commands" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mpmath" }, + { name = "humanize" }, + { name = "langchain-core" }, + { name = "langgraph" }, + { name = "loguru" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "rich" }, + { name = "surrealdb" }, + { name = "typer" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921 } +sdist = { url = "https://files.pythonhosted.org/packages/7f/89/c0234679e93c619583e1b8552079114f59ae77c31013001113a80bd6216a/surreal_commands-1.1.1.tar.gz", hash = "sha256:6994f65d3a7574f965fea887dc2ad3797177260b3a07aba07246bf4d61926574", size = 156443 } wheels = [ - { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353 }, + { url = "https://files.pythonhosted.org/packages/ce/fe/a69762f6eacf14ec3b97eb16f97fc2fd276679caace36168adadc3264df2/surreal_commands-1.1.1-py3-none-any.whl", hash = "sha256:d4be9ee5bfbcfe9d3d962d161b2639dd9fdc8dcde0ce8fe0e3b4444c646fe421", size = 28960 }, ] [[package]] -name = "tabulate" -version = "0.9.0" +name = "surrealdb" +version = "1.0.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090 } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiohttp" }, + { name = "aiosignal" }, + { name = "async-timeout" }, + { name = "attrs" }, + { name = "cerberus" }, + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "frozenlist" }, + { name = "idna" }, + { name = "marshmallow" }, + { name = "multidict" }, + { name = "packaging" }, + { name = "propcache" }, + { name = "pytz" }, + { name = "requests" }, + { name = "typing-extensions" }, + { name = "urllib3" }, + { name = "websockets" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bf/ec/a9defd7b7bd36d71181b7081d9f3929f988aa66836874e7c8c1b89e2d582/surrealdb-1.0.4.tar.gz", hash = "sha256:f582bb78784c142c7432d743c6fa60e2875a081537087dea8bfb5b1a468864f1", size = 47942 } wheels = [ - { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252 }, + { url = "https://files.pythonhosted.org/packages/b1/d4/1650a734206bfdfb112fb14db8ffaf3195385dd0fb8534396dbdb1814d22/surrealdb-1.0.4-py3-none-any.whl", hash = "sha256:0c617f572addd1e004e5ed83517518b6a83d0ba7f87f19e18c11e22fa96bf95e", size = 58866 }, ] [[package]] @@ -4458,18 +3251,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248 }, ] -[[package]] -name = "tifffile" -version = "2025.6.11" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/11/9e/636e3e433c24da41dd639e0520db60750dbf5e938d023b83af8097382ea3/tifffile-2025.6.11.tar.gz", hash = "sha256:0ece4c2e7a10656957d568a093b07513c0728d30c1bd8cc12725901fffdb7143", size = 370125 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/d8/1ba8f32bfc9cb69e37edeca93738e883f478fbe84ae401f72c0d8d507841/tifffile-2025.6.11-py3-none-any.whl", hash = "sha256:32effb78b10b3a283eb92d4ebf844ae7e93e151458b0412f38518b4e6d2d7542", size = 230800 }, -] - [[package]] name = "tiktoken" version = "0.9.0" @@ -4494,41 +3275,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5b/64/b16003419a1d7728d0d8c0d56a4c24325e7b10a21a9dd1fc0f7115c02f0a/tiktoken-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:5a62d7a25225bafed786a524c1b9f0910a1128f4232615bf3f8257a73aaa3b16", size = 894897 }, ] -[[package]] -name = "tinycss2" -version = "1.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "webencodings" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, -] - [[package]] name = "tokenizers" -version = "0.21.1" +version = "0.21.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "huggingface-hub" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/92/76/5ac0c97f1117b91b7eb7323dcd61af80d72f790b4df71249a7850c195f30/tokenizers-0.21.1.tar.gz", hash = "sha256:a1bb04dc5b448985f86ecd4b05407f5a8d97cb2c0532199b2a302a604a0165ab", size = 343256 } +sdist = { url = "https://files.pythonhosted.org/packages/ab/2d/b0fce2b8201635f60e8c95990080f58461cc9ca3d5026de2e900f38a7f21/tokenizers-0.21.2.tar.gz", hash = "sha256:fdc7cffde3e2113ba0e6cc7318c40e3438a4d74bbc62bf04bcc63bdfb082ac77", size = 351545 } wheels = [ - { url = "https://files.pythonhosted.org/packages/a5/1f/328aee25f9115bf04262e8b4e5a2050b7b7cf44b59c74e982db7270c7f30/tokenizers-0.21.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:e78e413e9e668ad790a29456e677d9d3aa50a9ad311a40905d6861ba7692cf41", size = 2780767 }, - { url = "https://files.pythonhosted.org/packages/ae/1a/4526797f3719b0287853f12c5ad563a9be09d446c44ac784cdd7c50f76ab/tokenizers-0.21.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:cd51cd0a91ecc801633829fcd1fda9cf8682ed3477c6243b9a095539de4aecf3", size = 2650555 }, - { url = "https://files.pythonhosted.org/packages/4d/7a/a209b29f971a9fdc1da86f917fe4524564924db50d13f0724feed37b2a4d/tokenizers-0.21.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28da6b72d4fb14ee200a1bd386ff74ade8992d7f725f2bde2c495a9a98cf4d9f", size = 2937541 }, - { url = "https://files.pythonhosted.org/packages/3c/1e/b788b50ffc6191e0b1fc2b0d49df8cff16fe415302e5ceb89f619d12c5bc/tokenizers-0.21.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:34d8cfde551c9916cb92014e040806122295a6800914bab5865deb85623931cf", size = 2819058 }, - { url = "https://files.pythonhosted.org/packages/36/aa/3626dfa09a0ecc5b57a8c58eeaeb7dd7ca9a37ad9dd681edab5acd55764c/tokenizers-0.21.1-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aaa852d23e125b73d283c98f007e06d4595732104b65402f46e8ef24b588d9f8", size = 3133278 }, - { url = "https://files.pythonhosted.org/packages/a4/4d/8fbc203838b3d26269f944a89459d94c858f5b3f9a9b6ee9728cdcf69161/tokenizers-0.21.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a21a15d5c8e603331b8a59548bbe113564136dc0f5ad8306dd5033459a226da0", size = 3144253 }, - { url = "https://files.pythonhosted.org/packages/d8/1b/2bd062adeb7c7511b847b32e356024980c0ffcf35f28947792c2d8ad2288/tokenizers-0.21.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2fdbd4c067c60a0ac7eca14b6bd18a5bebace54eb757c706b47ea93204f7a37c", size = 3398225 }, - { url = "https://files.pythonhosted.org/packages/8a/63/38be071b0c8e06840bc6046991636bcb30c27f6bb1e670f4f4bc87cf49cc/tokenizers-0.21.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dd9a0061e403546f7377df940e866c3e678d7d4e9643d0461ea442b4f89e61a", size = 3038874 }, - { url = "https://files.pythonhosted.org/packages/ec/83/afa94193c09246417c23a3c75a8a0a96bf44ab5630a3015538d0c316dd4b/tokenizers-0.21.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:db9484aeb2e200c43b915a1a0150ea885e35f357a5a8fabf7373af333dcc8dbf", size = 9014448 }, - { url = "https://files.pythonhosted.org/packages/ae/b3/0e1a37d4f84c0f014d43701c11eb8072704f6efe8d8fc2dcdb79c47d76de/tokenizers-0.21.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:ed248ab5279e601a30a4d67bdb897ecbe955a50f1e7bb62bd99f07dd11c2f5b6", size = 8937877 }, - { url = "https://files.pythonhosted.org/packages/ac/33/ff08f50e6d615eb180a4a328c65907feb6ded0b8f990ec923969759dc379/tokenizers-0.21.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:9ac78b12e541d4ce67b4dfd970e44c060a2147b9b2a21f509566d556a509c67d", size = 9186645 }, - { url = "https://files.pythonhosted.org/packages/5f/aa/8ae85f69a9f6012c6f8011c6f4aa1c96154c816e9eea2e1b758601157833/tokenizers-0.21.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e5a69c1a4496b81a5ee5d2c1f3f7fbdf95e90a0196101b0ee89ed9956b8a168f", size = 9384380 }, - { url = "https://files.pythonhosted.org/packages/e8/5b/a5d98c89f747455e8b7a9504910c865d5e51da55e825a7ae641fb5ff0a58/tokenizers-0.21.1-cp39-abi3-win32.whl", hash = "sha256:1039a3a5734944e09de1d48761ade94e00d0fa760c0e0551151d4dd851ba63e3", size = 2239506 }, - { url = "https://files.pythonhosted.org/packages/e6/b6/072a8e053ae600dcc2ac0da81a23548e3b523301a442a6ca900e92ac35be/tokenizers-0.21.1-cp39-abi3-win_amd64.whl", hash = "sha256:0f0dcbcc9f6e13e675a66d7a5f2f225a736745ce484c1a4e07476a89ccdad382", size = 2435481 }, + { url = "https://files.pythonhosted.org/packages/1d/cc/2936e2d45ceb130a21d929743f1e9897514691bec123203e10837972296f/tokenizers-0.21.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:342b5dfb75009f2255ab8dec0041287260fed5ce00c323eb6bab639066fef8ec", size = 2875206 }, + { url = "https://files.pythonhosted.org/packages/6c/e6/33f41f2cc7861faeba8988e7a77601407bf1d9d28fc79c5903f8f77df587/tokenizers-0.21.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:126df3205d6f3a93fea80c7a8a266a78c1bd8dd2fe043386bafdd7736a23e45f", size = 2732655 }, + { url = "https://files.pythonhosted.org/packages/33/2b/1791eb329c07122a75b01035b1a3aa22ad139f3ce0ece1b059b506d9d9de/tokenizers-0.21.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a32cd81be21168bd0d6a0f0962d60177c447a1aa1b1e48fa6ec9fc728ee0b12", size = 3019202 }, + { url = "https://files.pythonhosted.org/packages/05/15/fd2d8104faa9f86ac68748e6f7ece0b5eb7983c7efc3a2c197cb98c99030/tokenizers-0.21.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8bd8999538c405133c2ab999b83b17c08b7fc1b48c1ada2469964605a709ef91", size = 2934539 }, + { url = "https://files.pythonhosted.org/packages/a5/2e/53e8fd053e1f3ffbe579ca5f9546f35ac67cf0039ed357ad7ec57f5f5af0/tokenizers-0.21.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5e9944e61239b083a41cf8fc42802f855e1dca0f499196df37a8ce219abac6eb", size = 3248665 }, + { url = "https://files.pythonhosted.org/packages/00/15/79713359f4037aa8f4d1f06ffca35312ac83629da062670e8830917e2153/tokenizers-0.21.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:514cd43045c5d546f01142ff9c79a96ea69e4b5cda09e3027708cb2e6d5762ab", size = 3451305 }, + { url = "https://files.pythonhosted.org/packages/38/5f/959f3a8756fc9396aeb704292777b84f02a5c6f25c3fc3ba7530db5feb2c/tokenizers-0.21.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1b9405822527ec1e0f7d8d2fdb287a5730c3a6518189c968254a8441b21faae", size = 3214757 }, + { url = "https://files.pythonhosted.org/packages/c5/74/f41a432a0733f61f3d21b288de6dfa78f7acff309c6f0f323b2833e9189f/tokenizers-0.21.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fed9a4d51c395103ad24f8e7eb976811c57fbec2af9f133df471afcd922e5020", size = 3121887 }, + { url = "https://files.pythonhosted.org/packages/3c/6a/bc220a11a17e5d07b0dfb3b5c628621d4dcc084bccd27cfaead659963016/tokenizers-0.21.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2c41862df3d873665ec78b6be36fcc30a26e3d4902e9dd8608ed61d49a48bc19", size = 9091965 }, + { url = "https://files.pythonhosted.org/packages/6c/bd/ac386d79c4ef20dc6f39c4706640c24823dca7ebb6f703bfe6b5f0292d88/tokenizers-0.21.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:ed21dc7e624e4220e21758b2e62893be7101453525e3d23264081c9ef9a6d00d", size = 9053372 }, + { url = "https://files.pythonhosted.org/packages/63/7b/5440bf203b2a5358f074408f7f9c42884849cd9972879e10ee6b7a8c3b3d/tokenizers-0.21.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:0e73770507e65a0e0e2a1affd6b03c36e3bc4377bd10c9ccf51a82c77c0fe365", size = 9298632 }, + { url = "https://files.pythonhosted.org/packages/a4/d2/faa1acac3f96a7427866e94ed4289949b2524f0c1878512516567d80563c/tokenizers-0.21.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:106746e8aa9014a12109e58d540ad5465b4c183768ea96c03cbc24c44d329958", size = 9470074 }, + { url = "https://files.pythonhosted.org/packages/d8/a5/896e1ef0707212745ae9f37e84c7d50269411aef2e9ccd0de63623feecdf/tokenizers-0.21.2-cp39-abi3-win32.whl", hash = "sha256:cabda5a6d15d620b6dfe711e1af52205266d05b379ea85a8a301b3593c60e962", size = 2330115 }, + { url = "https://files.pythonhosted.org/packages/13/c3/cc2755ee10be859c4338c962a35b9a663788c0c0b50c0bdd8078fb6870cf/tokenizers-0.21.2-cp39-abi3-win_amd64.whl", hash = "sha256:58747bb898acdb1007f37a7bbe614346e98dc28708ffb66a3fd50ce169ac6c98", size = 2509918 }, ] [[package]] @@ -4569,65 +3338,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, ] -[[package]] -name = "torch" -version = "2.7.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "filelock" }, - { name = "fsspec" }, - { name = "jinja2" }, - { name = "networkx" }, - { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "setuptools", marker = "python_full_version >= '3.12'" }, - { name = "sympy" }, - { name = "triton", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" }, - { name = "typing-extensions" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/11/56/2eae3494e3d375533034a8e8cf0ba163363e996d85f0629441fa9d9843fe/torch-2.7.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:236f501f2e383f1cb861337bdf057712182f910f10aeaf509065d54d339e49b2", size = 99093039 }, - { url = "https://files.pythonhosted.org/packages/e5/94/34b80bd172d0072c9979708ccd279c2da2f55c3ef318eceec276ab9544a4/torch-2.7.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:06eea61f859436622e78dd0cdd51dbc8f8c6d76917a9cf0555a333f9eac31ec1", size = 821174704 }, - { url = "https://files.pythonhosted.org/packages/50/9e/acf04ff375b0b49a45511c55d188bcea5c942da2aaf293096676110086d1/torch-2.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:8273145a2e0a3c6f9fd2ac36762d6ee89c26d430e612b95a99885df083b04e52", size = 216095937 }, - { url = "https://files.pythonhosted.org/packages/5b/2b/d36d57c66ff031f93b4fa432e86802f84991477e522adcdffd314454326b/torch-2.7.1-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730", size = 68640034 }, - { url = "https://files.pythonhosted.org/packages/87/93/fb505a5022a2e908d81fe9a5e0aa84c86c0d5f408173be71c6018836f34e/torch-2.7.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:27ea1e518df4c9de73af7e8a720770f3628e7f667280bce2be7a16292697e3fa", size = 98948276 }, - { url = "https://files.pythonhosted.org/packages/56/7e/67c3fe2b8c33f40af06326a3d6ae7776b3e3a01daa8f71d125d78594d874/torch-2.7.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c33360cfc2edd976c2633b3b66c769bdcbbf0e0b6550606d188431c81e7dd1fc", size = 821025792 }, - { url = "https://files.pythonhosted.org/packages/a1/37/a37495502bc7a23bf34f89584fa5a78e25bae7b8da513bc1b8f97afb7009/torch-2.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:d8bf6e1856ddd1807e79dc57e54d3335f2b62e6f316ed13ed3ecfe1fc1df3d8b", size = 216050349 }, - { url = "https://files.pythonhosted.org/packages/3a/60/04b77281c730bb13460628e518c52721257814ac6c298acd25757f6a175c/torch-2.7.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:787687087412c4bd68d315e39bc1223f08aae1d16a9e9771d95eabbb04ae98fb", size = 68645146 }, -] - -[[package]] -name = "torchvision" -version = "0.22.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, - { name = "pillow" }, - { name = "torch" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/f6/00/bdab236ef19da050290abc2b5203ff9945c84a1f2c7aab73e8e9c8c85669/torchvision-0.22.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4addf626e2b57fc22fd6d329cf1346d474497672e6af8383b7b5b636fba94a53", size = 1947827 }, - { url = "https://files.pythonhosted.org/packages/ac/d0/18f951b2be3cfe48c0027b349dcc6fde950e3dc95dd83e037e86f284f6fd/torchvision-0.22.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:8b4a53a6067d63adba0c52f2b8dd2290db649d642021674ee43c0c922f0c6a69", size = 2514021 }, - { url = "https://files.pythonhosted.org/packages/c3/1a/63eb241598b36d37a0221e10af357da34bd33402ccf5c0765e389642218a/torchvision-0.22.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:b7866a3b326413e67724ac46f1ee594996735e10521ba9e6cdbe0fa3cd98c2f2", size = 7487300 }, - { url = "https://files.pythonhosted.org/packages/e5/73/1b009b42fe4a7774ba19c23c26bb0f020d68525c417a348b166f1c56044f/torchvision-0.22.1-cp311-cp311-win_amd64.whl", hash = "sha256:bb3f6df6f8fd415ce38ec4fd338376ad40c62e86052d7fc706a0dd51efac1718", size = 1707989 }, - { url = "https://files.pythonhosted.org/packages/02/90/f4e99a5112dc221cf68a485e853cc3d9f3f1787cb950b895f3ea26d1ea98/torchvision-0.22.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:153f1790e505bd6da123e21eee6e83e2e155df05c0fe7d56347303067d8543c5", size = 1947827 }, - { url = "https://files.pythonhosted.org/packages/25/f6/53e65384cdbbe732cc2106bb04f7fb908487e4fb02ae4a1613ce6904a122/torchvision-0.22.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:964414eef19459d55a10e886e2fca50677550e243586d1678f65e3f6f6bac47a", size = 2514576 }, - { url = "https://files.pythonhosted.org/packages/17/8b/155f99042f9319bd7759536779b2a5b67cbd4f89c380854670850f89a2f4/torchvision-0.22.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:699c2d70d33951187f6ed910ea05720b9b4aaac1dcc1135f53162ce7d42481d3", size = 7485962 }, - { url = "https://files.pythonhosted.org/packages/05/17/e45d5cd3627efdb47587a0634179a3533593436219de3f20c743672d2a79/torchvision-0.22.1-cp312-cp312-win_amd64.whl", hash = "sha256:75e0897da7a8e43d78632f66f2bdc4f6e26da8d3f021a7c0fa83746073c2597b", size = 1707992 }, -] - [[package]] name = "tornado" version = "6.5.1" @@ -4668,42 +3378,9 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, ] -[[package]] -name = "transformers" -version = "4.52.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "filelock" }, - { name = "huggingface-hub" }, - { name = "numpy" }, - { name = "packaging" }, - { name = "pyyaml" }, - { name = "regex" }, - { name = "requests" }, - { name = "safetensors" }, - { name = "tokenizers" }, - { name = "tqdm" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/da/a9/275037087f9d846580b02f2d7cae0e0a6955d46f84583d0151d6227bd416/transformers-4.52.4.tar.gz", hash = "sha256:aff3764441c1adc192a08dba49740d3cbbcb72d850586075aed6bd89b98203e6", size = 8945376 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/96/f2/25b27b396af03d5b64e61976b14f7209e2939e9e806c10749b6d277c273e/transformers-4.52.4-py3-none-any.whl", hash = "sha256:203f5c19416d5877e36e88633943761719538a25d9775977a24fe77a1e5adfc7", size = 10460375 }, -] - -[[package]] -name = "triton" -version = "3.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "setuptools", marker = "(platform_machine != 'aarch64' and platform_system == 'Linux') or (platform_system != 'Darwin' and platform_system != 'Linux')" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/21/2f/3e56ea7b58f80ff68899b1dbe810ff257c9d177d288c6b0f55bf2fe4eb50/triton-3.3.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b31e3aa26f8cb3cc5bf4e187bf737cbacf17311e1112b781d4a059353dfd731b", size = 155689937 }, - { url = "https://files.pythonhosted.org/packages/24/5f/950fb373bf9c01ad4eb5a8cd5eaf32cdf9e238c02f9293557a2129b9c4ac/triton-3.3.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9999e83aba21e1a78c1f36f21bce621b77bcaa530277a50484a7cb4a822f6e43", size = 155669138 }, -] - [[package]] name = "typer" -version = "0.12.5" +version = "0.16.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -4711,18 +3388,9 @@ dependencies = [ { name = "shellingham" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c5/58/a79003b91ac2c6890fc5d90145c662fd5771c6f11447f116b63300436bc9/typer-0.12.5.tar.gz", hash = "sha256:f592f089bedcc8ec1b974125d64851029c3b1af145f04aca64d69410f0c9b722", size = 98953 } +sdist = { url = "https://files.pythonhosted.org/packages/c5/8c/7d682431efca5fd290017663ea4588bf6f2c6aad085c7f108c5dbc316e70/typer-0.16.0.tar.gz", hash = "sha256:af377ffaee1dbe37ae9440cb4e8f11686ea5ce4e9bae01b84ae7c63b87f1dd3b", size = 102625 } wheels = [ - { url = "https://files.pythonhosted.org/packages/a8/2b/886d13e742e514f704c33c4caa7df0f3b89e5a25ef8db02aa9ca3d9535d5/typer-0.12.5-py3-none-any.whl", hash = "sha256:62fe4e471711b147e3365034133904df3e235698399bc4de2b36c8579298d52b", size = 47288 }, -] - -[[package]] -name = "types-pyyaml" -version = "6.0.12.20250516" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4e/22/59e2aeb48ceeee1f7cd4537db9568df80d62bdb44a7f9e743502ea8aab9c/types_pyyaml-6.0.12.20250516.tar.gz", hash = "sha256:9f21a70216fc0fa1b216a8176db5f9e0af6eb35d2f2932acb87689d03a5bf6ba", size = 17378 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/99/5f/e0af6f7f6a260d9af67e1db4f54d732abad514252a7a378a6c4d17dd1036/types_pyyaml-6.0.12.20250516-py3-none-any.whl", hash = "sha256:8478208feaeb53a34cb5d970c56a7cd76b72659442e733e268a94dc72b2d0530", size = 20312 }, + { url = "https://files.pythonhosted.org/packages/76/42/3efaf858001d2c2913de7f354563e3a3a2f0decae3efe98427125a8f441e/typer-0.16.0-py3-none-any.whl", hash = "sha256:1f79bed11d4d02d4310e3c1b7ba594183bcedb0ac73b27a9e5f28f6fb5b98855", size = 46317 }, ] [[package]] @@ -4739,11 +3407,11 @@ wheels = [ [[package]] name = "typing-extensions" -version = "4.14.0" +version = "4.12.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d1/bc/51647cd02527e87d05cb083ccc402f93e441606ff1f01739a62c8ad09ba5/typing_extensions-4.14.0.tar.gz", hash = "sha256:8676b788e32f02ab42d9e7c61324048ae4c6d844a399eebace3d4979d75ceef4", size = 107423 } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } wheels = [ - { url = "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl", hash = "sha256:a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af", size = 43839 }, + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, ] [[package]] @@ -4780,15 +3448,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 }, ] -[[package]] -name = "uritemplate" -version = "4.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/98/60/f174043244c5306c9988380d2cb10009f91563fc4b31293d27e17201af56/uritemplate-4.2.0.tar.gz", hash = "sha256:480c2ed180878955863323eea31b0ede668795de182617fef9c6ca09e6ec9d0e", size = 33267 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/99/3ae339466c9183ea5b8ae87b34c0b897eda475d2aec2307cae60e5cd4f29/uritemplate-4.2.0-py3-none-any.whl", hash = "sha256:962201ba1c4edcab02e60f9a0d3821e82dfc5d2d6662a21abd533879bdb8a686", size = 11488 }, -] - [[package]] name = "urllib3" version = "2.5.0" @@ -4798,6 +3457,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795 }, ] +[[package]] +name = "uvicorn" +version = "0.35.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/42/e0e305207bb88c6b8d3061399c6a961ffe5fbb7e2aa63c9234df7259e9cd/uvicorn-0.35.0.tar.gz", hash = "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01", size = 78473 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/e2/dc81b1bd1dcfe91735810265e9d26bc8ec5da45b4c0f6237e286819194c3/uvicorn-0.35.0-py3-none-any.whl", hash = "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a", size = 66406 }, +] + [[package]] name = "validators" version = "0.35.0" @@ -4854,53 +3526,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, ] -[[package]] -name = "webencodings" -version = "0.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, -] - [[package]] name = "websockets" -version = "13.1" +version = "14.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e2/73/9223dbc7be3dcaf2a7bbf756c351ec8da04b1fa573edaf545b95f6b0c7fd/websockets-13.1.tar.gz", hash = "sha256:a3b3366087c1bc0a2795111edcadddb8b3b59509d5db5d7ea3fdd69f954a8878", size = 158549 } +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5", size = 164394 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b2/f0/cf0b8a30d86b49e267ac84addbebbc7a48a6e7bb7c19db80f62411452311/websockets-13.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:61fc0dfcda609cda0fc9fe7977694c0c59cf9d749fbb17f4e9483929e3c48a19", size = 157813 }, - { url = "https://files.pythonhosted.org/packages/bf/e7/22285852502e33071a8cf0ac814f8988480ec6db4754e067b8b9d0e92498/websockets-13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ceec59f59d092c5007e815def4ebb80c2de330e9588e101cf8bd94c143ec78a5", size = 155469 }, - { url = "https://files.pythonhosted.org/packages/68/d4/c8c7c1e5b40ee03c5cc235955b0fb1ec90e7e37685a5f69229ad4708dcde/websockets-13.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c1dca61c6db1166c48b95198c0b7d9c990b30c756fc2923cc66f68d17dc558fd", size = 155717 }, - { url = "https://files.pythonhosted.org/packages/c9/e4/c50999b9b848b1332b07c7fd8886179ac395cb766fda62725d1539e7bc6c/websockets-13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:308e20f22c2c77f3f39caca508e765f8725020b84aa963474e18c59accbf4c02", size = 165379 }, - { url = "https://files.pythonhosted.org/packages/bc/49/4a4ad8c072f18fd79ab127650e47b160571aacfc30b110ee305ba25fffc9/websockets-13.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:62d516c325e6540e8a57b94abefc3459d7dab8ce52ac75c96cad5549e187e3a7", size = 164376 }, - { url = "https://files.pythonhosted.org/packages/af/9b/8c06d425a1d5a74fd764dd793edd02be18cf6fc3b1ccd1f29244ba132dc0/websockets-13.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87c6e35319b46b99e168eb98472d6c7d8634ee37750d7693656dc766395df096", size = 164753 }, - { url = "https://files.pythonhosted.org/packages/d5/5b/0acb5815095ff800b579ffc38b13ab1b915b317915023748812d24e0c1ac/websockets-13.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5f9fee94ebafbc3117c30be1844ed01a3b177bb6e39088bc6b2fa1dc15572084", size = 165051 }, - { url = "https://files.pythonhosted.org/packages/30/93/c3891c20114eacb1af09dedfcc620c65c397f4fd80a7009cd12d9457f7f5/websockets-13.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7c1e90228c2f5cdde263253fa5db63e6653f1c00e7ec64108065a0b9713fa1b3", size = 164489 }, - { url = "https://files.pythonhosted.org/packages/28/09/af9e19885539759efa2e2cd29b8b3f9eecef7ecefea40d46612f12138b36/websockets-13.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6548f29b0e401eea2b967b2fdc1c7c7b5ebb3eeb470ed23a54cd45ef078a0db9", size = 164438 }, - { url = "https://files.pythonhosted.org/packages/b6/08/6f38b8e625b3d93de731f1d248cc1493327f16cb45b9645b3e791782cff0/websockets-13.1-cp311-cp311-win32.whl", hash = "sha256:c11d4d16e133f6df8916cc5b7e3e96ee4c44c936717d684a94f48f82edb7c92f", size = 158710 }, - { url = "https://files.pythonhosted.org/packages/fb/39/ec8832ecb9bb04a8d318149005ed8cee0ba4e0205835da99e0aa497a091f/websockets-13.1-cp311-cp311-win_amd64.whl", hash = "sha256:d04f13a1d75cb2b8382bdc16ae6fa58c97337253826dfe136195b7f89f661557", size = 159137 }, - { url = "https://files.pythonhosted.org/packages/df/46/c426282f543b3c0296cf964aa5a7bb17e984f58dde23460c3d39b3148fcf/websockets-13.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:9d75baf00138f80b48f1eac72ad1535aac0b6461265a0bcad391fc5aba875cfc", size = 157821 }, - { url = "https://files.pythonhosted.org/packages/aa/85/22529867010baac258da7c45848f9415e6cf37fef00a43856627806ffd04/websockets-13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9b6f347deb3dcfbfde1c20baa21c2ac0751afaa73e64e5b693bb2b848efeaa49", size = 155480 }, - { url = "https://files.pythonhosted.org/packages/29/2c/bdb339bfbde0119a6e84af43ebf6275278698a2241c2719afc0d8b0bdbf2/websockets-13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de58647e3f9c42f13f90ac7e5f58900c80a39019848c5547bc691693098ae1bd", size = 155715 }, - { url = "https://files.pythonhosted.org/packages/9f/d0/8612029ea04c5c22bf7af2fd3d63876c4eaeef9b97e86c11972a43aa0e6c/websockets-13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1b54689e38d1279a51d11e3467dd2f3a50f5f2e879012ce8f2d6943f00e83f0", size = 165647 }, - { url = "https://files.pythonhosted.org/packages/56/04/1681ed516fa19ca9083f26d3f3a302257e0911ba75009533ed60fbb7b8d1/websockets-13.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf1781ef73c073e6b0f90af841aaf98501f975d306bbf6221683dd594ccc52b6", size = 164592 }, - { url = "https://files.pythonhosted.org/packages/38/6f/a96417a49c0ed132bb6087e8e39a37db851c70974f5c724a4b2a70066996/websockets-13.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d23b88b9388ed85c6faf0e74d8dec4f4d3baf3ecf20a65a47b836d56260d4b9", size = 165012 }, - { url = "https://files.pythonhosted.org/packages/40/8b/fccf294919a1b37d190e86042e1a907b8f66cff2b61e9befdbce03783e25/websockets-13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3c78383585f47ccb0fcf186dcb8a43f5438bd7d8f47d69e0b56f71bf431a0a68", size = 165311 }, - { url = "https://files.pythonhosted.org/packages/c1/61/f8615cf7ce5fe538476ab6b4defff52beb7262ff8a73d5ef386322d9761d/websockets-13.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d6d300f8ec35c24025ceb9b9019ae9040c1ab2f01cddc2bcc0b518af31c75c14", size = 164692 }, - { url = "https://files.pythonhosted.org/packages/5c/f1/a29dd6046d3a722d26f182b783a7997d25298873a14028c4760347974ea3/websockets-13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a9dcaf8b0cc72a392760bb8755922c03e17a5a54e08cca58e8b74f6902b433cf", size = 164686 }, - { url = "https://files.pythonhosted.org/packages/0f/99/ab1cdb282f7e595391226f03f9b498f52109d25a2ba03832e21614967dfa/websockets-13.1-cp312-cp312-win32.whl", hash = "sha256:2f85cf4f2a1ba8f602298a853cec8526c2ca42a9a4b947ec236eaedb8f2dc80c", size = 158712 }, - { url = "https://files.pythonhosted.org/packages/46/93/e19160db48b5581feac8468330aa11b7292880a94a37d7030478596cc14e/websockets-13.1-cp312-cp312-win_amd64.whl", hash = "sha256:38377f8b0cdeee97c552d20cf1865695fcd56aba155ad1b4ca8779a5b6ef4ac3", size = 159145 }, - { url = "https://files.pythonhosted.org/packages/56/27/96a5cd2626d11c8280656c6c71d8ab50fe006490ef9971ccd154e0c42cd2/websockets-13.1-py3-none-any.whl", hash = "sha256:a9a396a6ad26130cdae92ae10c36af09d9bfe6cafe69670fd3b6da9b07b4044f", size = 152134 }, -] - -[[package]] -name = "wheel" -version = "0.44.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b7/a0/95e9e962c5fd9da11c1e28aa4c0d8210ab277b1ada951d2aee336b505813/wheel-0.44.0.tar.gz", hash = "sha256:a29c3f2817e95ab89aa4660681ad547c0e9547f20e75b0562fe7723c9a2a9d49", size = 100733 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/d1/9babe2ccaecff775992753d8686970b1e2755d21c8a63be73aba7a4e7d77/wheel-0.44.0-py3-none-any.whl", hash = "sha256:2376a90c98cc337d18623527a97c31797bd02bad0033d41547043a1cbfbe448f", size = 67059 }, + { url = "https://files.pythonhosted.org/packages/15/b6/504695fb9a33df0ca56d157f5985660b5fc5b4bf8c78f121578d2d653392/websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166", size = 163088 }, + { url = "https://files.pythonhosted.org/packages/81/26/ebfb8f6abe963c795122439c6433c4ae1e061aaedfc7eff32d09394afbae/websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f", size = 160745 }, + { url = "https://files.pythonhosted.org/packages/a1/c6/1435ad6f6dcbff80bb95e8986704c3174da8866ddb751184046f5c139ef6/websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/96/63/900c27cfe8be1a1f2433fc77cd46771cf26ba57e6bdc7cf9e63644a61863/websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c", size = 170543 }, + { url = "https://files.pythonhosted.org/packages/00/8b/bec2bdba92af0762d42d4410593c1d7d28e9bfd952c97a3729df603dc6ea/websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473", size = 169546 }, + { url = "https://files.pythonhosted.org/packages/6b/a9/37531cb5b994f12a57dec3da2200ef7aadffef82d888a4c29a0d781568e4/websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473", size = 169911 }, + { url = "https://files.pythonhosted.org/packages/60/d5/a6eadba2ed9f7e65d677fec539ab14a9b83de2b484ab5fe15d3d6d208c28/websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56", size = 170183 }, + { url = "https://files.pythonhosted.org/packages/76/57/a338ccb00d1df881c1d1ee1f2a20c9c1b5b29b51e9e0191ee515d254fea6/websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142", size = 169623 }, + { url = "https://files.pythonhosted.org/packages/64/22/e5f7c33db0cb2c1d03b79fd60d189a1da044e2661f5fd01d629451e1db89/websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d", size = 169583 }, + { url = "https://files.pythonhosted.org/packages/aa/2e/2b4662237060063a22e5fc40d46300a07142afe30302b634b4eebd717c07/websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a", size = 163969 }, + { url = "https://files.pythonhosted.org/packages/94/a5/0cda64e1851e73fc1ecdae6f42487babb06e55cb2f0dc8904b81d8ef6857/websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b", size = 164408 }, + { url = "https://files.pythonhosted.org/packages/c1/81/04f7a397653dc8bec94ddc071f34833e8b99b13ef1a3804c149d59f92c18/websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c", size = 163096 }, + { url = "https://files.pythonhosted.org/packages/ec/c5/de30e88557e4d70988ed4d2eabd73fd3e1e52456b9f3a4e9564d86353b6d/websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967", size = 160758 }, + { url = "https://files.pythonhosted.org/packages/e5/8c/d130d668781f2c77d106c007b6c6c1d9db68239107c41ba109f09e6c218a/websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda", size = 170815 }, + { url = "https://files.pythonhosted.org/packages/d8/b2/8070cb970c2e4122a6ef38bc5b203415fd46460e025652e1ee3f2f43a9a3/websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95", size = 169759 }, + { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3", size = 170178 }, + { url = "https://files.pythonhosted.org/packages/31/e0/812725b6deca8afd3a08a2e81b3c4c120c17f68c9b84522a520b816cda58/websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9", size = 170453 }, + { url = "https://files.pythonhosted.org/packages/66/d3/8275dbc231e5ba9bb0c4f93144394b4194402a7a0c8ffaca5307a58ab5e3/websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267", size = 169830 }, + { url = "https://files.pythonhosted.org/packages/a3/ae/e7d1a56755ae15ad5a94e80dd490ad09e345365199600b2629b18ee37bc7/websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe", size = 169824 }, + { url = "https://files.pythonhosted.org/packages/b6/32/88ccdd63cb261e77b882e706108d072e4f1c839ed723bf91a3e1f216bf60/websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205", size = 163981 }, + { url = "https://files.pythonhosted.org/packages/b3/7d/32cdb77990b3bdc34a306e0a0f73a1275221e9a66d869f6ff833c95b56ef/websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce", size = 164421 }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b", size = 157416 }, ] [[package]] @@ -4970,72 +3624,61 @@ wheels = [ [[package]] name = "yarl" -version = "1.20.1" +version = "1.18.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "idna" }, { name = "multidict" }, { name = "propcache" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3c/fb/efaa23fa4e45537b827620f04cf8f3cd658b76642205162e072703a5b963/yarl-1.20.1.tar.gz", hash = "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac", size = 186428 } +sdist = { url = "https://files.pythonhosted.org/packages/b7/9d/4b94a8e6d2b51b599516a5cb88e5bc99b4d8d4583e468057eaa29d5f0918/yarl-1.18.3.tar.gz", hash = "sha256:ac1801c45cbf77b6c99242eeff4fffb5e4e73a800b5c4ad4fc0be5def634d2e1", size = 181062 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/18/893b50efc2350e47a874c5c2d67e55a0ea5df91186b2a6f5ac52eff887cd/yarl-1.20.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:47ee6188fea634bdfaeb2cc420f5b3b17332e6225ce88149a17c413c77ff269e", size = 133833 }, - { url = "https://files.pythonhosted.org/packages/89/ed/b8773448030e6fc47fa797f099ab9eab151a43a25717f9ac043844ad5ea3/yarl-1.20.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d0f6500f69e8402d513e5eedb77a4e1818691e8f45e6b687147963514d84b44b", size = 91070 }, - { url = "https://files.pythonhosted.org/packages/e3/e3/409bd17b1e42619bf69f60e4f031ce1ccb29bd7380117a55529e76933464/yarl-1.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a8900a42fcdaad568de58887c7b2f602962356908eedb7628eaf6021a6e435b", size = 89818 }, - { url = "https://files.pythonhosted.org/packages/f8/77/64d8431a4d77c856eb2d82aa3de2ad6741365245a29b3a9543cd598ed8c5/yarl-1.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bad6d131fda8ef508b36be3ece16d0902e80b88ea7200f030a0f6c11d9e508d4", size = 347003 }, - { url = "https://files.pythonhosted.org/packages/8d/d2/0c7e4def093dcef0bd9fa22d4d24b023788b0a33b8d0088b51aa51e21e99/yarl-1.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:df018d92fe22aaebb679a7f89fe0c0f368ec497e3dda6cb81a567610f04501f1", size = 336537 }, - { url = "https://files.pythonhosted.org/packages/f0/f3/fc514f4b2cf02cb59d10cbfe228691d25929ce8f72a38db07d3febc3f706/yarl-1.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f969afbb0a9b63c18d0feecf0db09d164b7a44a053e78a7d05f5df163e43833", size = 362358 }, - { url = "https://files.pythonhosted.org/packages/ea/6d/a313ac8d8391381ff9006ac05f1d4331cee3b1efaa833a53d12253733255/yarl-1.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:812303eb4aa98e302886ccda58d6b099e3576b1b9276161469c25803a8db277d", size = 357362 }, - { url = "https://files.pythonhosted.org/packages/00/70/8f78a95d6935a70263d46caa3dd18e1f223cf2f2ff2037baa01a22bc5b22/yarl-1.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98c4a7d166635147924aa0bf9bfe8d8abad6fffa6102de9c99ea04a1376f91e8", size = 348979 }, - { url = "https://files.pythonhosted.org/packages/cb/05/42773027968968f4f15143553970ee36ead27038d627f457cc44bbbeecf3/yarl-1.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12e768f966538e81e6e7550f9086a6236b16e26cd964cf4df35349970f3551cf", size = 337274 }, - { url = "https://files.pythonhosted.org/packages/05/be/665634aa196954156741ea591d2f946f1b78ceee8bb8f28488bf28c0dd62/yarl-1.20.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe41919b9d899661c5c28a8b4b0acf704510b88f27f0934ac7a7bebdd8938d5e", size = 363294 }, - { url = "https://files.pythonhosted.org/packages/eb/90/73448401d36fa4e210ece5579895731f190d5119c4b66b43b52182e88cd5/yarl-1.20.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8601bc010d1d7780592f3fc1bdc6c72e2b6466ea34569778422943e1a1f3c389", size = 358169 }, - { url = "https://files.pythonhosted.org/packages/c3/b0/fce922d46dc1eb43c811f1889f7daa6001b27a4005587e94878570300881/yarl-1.20.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:daadbdc1f2a9033a2399c42646fbd46da7992e868a5fe9513860122d7fe7a73f", size = 362776 }, - { url = "https://files.pythonhosted.org/packages/f1/0d/b172628fce039dae8977fd22caeff3eeebffd52e86060413f5673767c427/yarl-1.20.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:03aa1e041727cb438ca762628109ef1333498b122e4c76dd858d186a37cec845", size = 381341 }, - { url = "https://files.pythonhosted.org/packages/6b/9b/5b886d7671f4580209e855974fe1cecec409aa4a89ea58b8f0560dc529b1/yarl-1.20.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:642980ef5e0fa1de5fa96d905c7e00cb2c47cb468bfcac5a18c58e27dbf8d8d1", size = 379988 }, - { url = "https://files.pythonhosted.org/packages/73/be/75ef5fd0fcd8f083a5d13f78fd3f009528132a1f2a1d7c925c39fa20aa79/yarl-1.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:86971e2795584fe8c002356d3b97ef6c61862720eeff03db2a7c86b678d85b3e", size = 371113 }, - { url = "https://files.pythonhosted.org/packages/50/4f/62faab3b479dfdcb741fe9e3f0323e2a7d5cd1ab2edc73221d57ad4834b2/yarl-1.20.1-cp311-cp311-win32.whl", hash = "sha256:597f40615b8d25812f14562699e287f0dcc035d25eb74da72cae043bb884d773", size = 81485 }, - { url = "https://files.pythonhosted.org/packages/f0/09/d9c7942f8f05c32ec72cd5c8e041c8b29b5807328b68b4801ff2511d4d5e/yarl-1.20.1-cp311-cp311-win_amd64.whl", hash = "sha256:26ef53a9e726e61e9cd1cda6b478f17e350fb5800b4bd1cd9fe81c4d91cfeb2e", size = 86686 }, - { url = "https://files.pythonhosted.org/packages/5f/9a/cb7fad7d73c69f296eda6815e4a2c7ed53fc70c2f136479a91c8e5fbdb6d/yarl-1.20.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdcc4cd244e58593a4379fe60fdee5ac0331f8eb70320a24d591a3be197b94a9", size = 133667 }, - { url = "https://files.pythonhosted.org/packages/67/38/688577a1cb1e656e3971fb66a3492501c5a5df56d99722e57c98249e5b8a/yarl-1.20.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b29a2c385a5f5b9c7d9347e5812b6f7ab267193c62d282a540b4fc528c8a9d2a", size = 91025 }, - { url = "https://files.pythonhosted.org/packages/50/ec/72991ae51febeb11a42813fc259f0d4c8e0507f2b74b5514618d8b640365/yarl-1.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1112ae8154186dfe2de4732197f59c05a83dc814849a5ced892b708033f40dc2", size = 89709 }, - { url = "https://files.pythonhosted.org/packages/99/da/4d798025490e89426e9f976702e5f9482005c548c579bdae792a4c37769e/yarl-1.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90bbd29c4fe234233f7fa2b9b121fb63c321830e5d05b45153a2ca68f7d310ee", size = 352287 }, - { url = "https://files.pythonhosted.org/packages/1a/26/54a15c6a567aac1c61b18aa0f4b8aa2e285a52d547d1be8bf48abe2b3991/yarl-1.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:680e19c7ce3710ac4cd964e90dad99bf9b5029372ba0c7cbfcd55e54d90ea819", size = 345429 }, - { url = "https://files.pythonhosted.org/packages/d6/95/9dcf2386cb875b234353b93ec43e40219e14900e046bf6ac118f94b1e353/yarl-1.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a979218c1fdb4246a05efc2cc23859d47c89af463a90b99b7c56094daf25a16", size = 365429 }, - { url = "https://files.pythonhosted.org/packages/91/b2/33a8750f6a4bc224242a635f5f2cff6d6ad5ba651f6edcccf721992c21a0/yarl-1.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255b468adf57b4a7b65d8aad5b5138dce6a0752c139965711bdcb81bc370e1b6", size = 363862 }, - { url = "https://files.pythonhosted.org/packages/98/28/3ab7acc5b51f4434b181b0cee8f1f4b77a65919700a355fb3617f9488874/yarl-1.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a97d67108e79cfe22e2b430d80d7571ae57d19f17cda8bb967057ca8a7bf5bfd", size = 355616 }, - { url = "https://files.pythonhosted.org/packages/36/a3/f666894aa947a371724ec7cd2e5daa78ee8a777b21509b4252dd7bd15e29/yarl-1.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8570d998db4ddbfb9a590b185a0a33dbf8aafb831d07a5257b4ec9948df9cb0a", size = 339954 }, - { url = "https://files.pythonhosted.org/packages/f1/81/5f466427e09773c04219d3450d7a1256138a010b6c9f0af2d48565e9ad13/yarl-1.20.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97c75596019baae7c71ccf1d8cc4738bc08134060d0adfcbe5642f778d1dca38", size = 365575 }, - { url = "https://files.pythonhosted.org/packages/2e/e3/e4b0ad8403e97e6c9972dd587388940a032f030ebec196ab81a3b8e94d31/yarl-1.20.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1c48912653e63aef91ff988c5432832692ac5a1d8f0fb8a33091520b5bbe19ef", size = 365061 }, - { url = "https://files.pythonhosted.org/packages/ac/99/b8a142e79eb86c926f9f06452eb13ecb1bb5713bd01dc0038faf5452e544/yarl-1.20.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4c3ae28f3ae1563c50f3d37f064ddb1511ecc1d5584e88c6b7c63cf7702a6d5f", size = 364142 }, - { url = "https://files.pythonhosted.org/packages/34/f2/08ed34a4a506d82a1a3e5bab99ccd930a040f9b6449e9fd050320e45845c/yarl-1.20.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c5e9642f27036283550f5f57dc6156c51084b458570b9d0d96100c8bebb186a8", size = 381894 }, - { url = "https://files.pythonhosted.org/packages/92/f8/9a3fbf0968eac704f681726eff595dce9b49c8a25cd92bf83df209668285/yarl-1.20.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2c26b0c49220d5799f7b22c6838409ee9bc58ee5c95361a4d7831f03cc225b5a", size = 383378 }, - { url = "https://files.pythonhosted.org/packages/af/85/9363f77bdfa1e4d690957cd39d192c4cacd1c58965df0470a4905253b54f/yarl-1.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564ab3d517e3d01c408c67f2e5247aad4019dcf1969982aba3974b4093279004", size = 374069 }, - { url = "https://files.pythonhosted.org/packages/35/99/9918c8739ba271dcd935400cff8b32e3cd319eaf02fcd023d5dcd487a7c8/yarl-1.20.1-cp312-cp312-win32.whl", hash = "sha256:daea0d313868da1cf2fac6b2d3a25c6e3a9e879483244be38c8e6a41f1d876a5", size = 81249 }, - { url = "https://files.pythonhosted.org/packages/eb/83/5d9092950565481b413b31a23e75dd3418ff0a277d6e0abf3729d4d1ce25/yarl-1.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:48ea7d7f9be0487339828a4de0360d7ce0efc06524a48e1810f945c45b813698", size = 86710 }, - { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542 }, + { url = "https://files.pythonhosted.org/packages/40/93/282b5f4898d8e8efaf0790ba6d10e2245d2c9f30e199d1a85cae9356098c/yarl-1.18.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8503ad47387b8ebd39cbbbdf0bf113e17330ffd339ba1144074da24c545f0069", size = 141555 }, + { url = "https://files.pythonhosted.org/packages/6d/9c/0a49af78df099c283ca3444560f10718fadb8a18dc8b3edf8c7bd9fd7d89/yarl-1.18.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:02ddb6756f8f4517a2d5e99d8b2f272488e18dd0bfbc802f31c16c6c20f22193", size = 94351 }, + { url = "https://files.pythonhosted.org/packages/5a/a1/205ab51e148fdcedad189ca8dd587794c6f119882437d04c33c01a75dece/yarl-1.18.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:67a283dd2882ac98cc6318384f565bffc751ab564605959df4752d42483ad889", size = 92286 }, + { url = "https://files.pythonhosted.org/packages/ed/fe/88b690b30f3f59275fb674f5f93ddd4a3ae796c2b62e5bb9ece8a4914b83/yarl-1.18.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d980e0325b6eddc81331d3f4551e2a333999fb176fd153e075c6d1c2530aa8a8", size = 340649 }, + { url = "https://files.pythonhosted.org/packages/07/eb/3b65499b568e01f36e847cebdc8d7ccb51fff716dbda1ae83c3cbb8ca1c9/yarl-1.18.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b643562c12680b01e17239be267bc306bbc6aac1f34f6444d1bded0c5ce438ca", size = 356623 }, + { url = "https://files.pythonhosted.org/packages/33/46/f559dc184280b745fc76ec6b1954de2c55595f0ec0a7614238b9ebf69618/yarl-1.18.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c017a3b6df3a1bd45b9fa49a0f54005e53fbcad16633870104b66fa1a30a29d8", size = 354007 }, + { url = "https://files.pythonhosted.org/packages/af/ba/1865d85212351ad160f19fb99808acf23aab9a0f8ff31c8c9f1b4d671fc9/yarl-1.18.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75674776d96d7b851b6498f17824ba17849d790a44d282929c42dbb77d4f17ae", size = 344145 }, + { url = "https://files.pythonhosted.org/packages/94/cb/5c3e975d77755d7b3d5193e92056b19d83752ea2da7ab394e22260a7b824/yarl-1.18.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ccaa3a4b521b780a7e771cc336a2dba389a0861592bbce09a476190bb0c8b4b3", size = 336133 }, + { url = "https://files.pythonhosted.org/packages/19/89/b77d3fd249ab52a5c40859815765d35c91425b6bb82e7427ab2f78f5ff55/yarl-1.18.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2d06d3005e668744e11ed80812e61efd77d70bb7f03e33c1598c301eea20efbb", size = 347967 }, + { url = "https://files.pythonhosted.org/packages/35/bd/f6b7630ba2cc06c319c3235634c582a6ab014d52311e7d7c22f9518189b5/yarl-1.18.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:9d41beda9dc97ca9ab0b9888cb71f7539124bc05df02c0cff6e5acc5a19dcc6e", size = 346397 }, + { url = "https://files.pythonhosted.org/packages/18/1a/0b4e367d5a72d1f095318344848e93ea70da728118221f84f1bf6c1e39e7/yarl-1.18.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ba23302c0c61a9999784e73809427c9dbedd79f66a13d84ad1b1943802eaaf59", size = 350206 }, + { url = "https://files.pythonhosted.org/packages/b5/cf/320fff4367341fb77809a2d8d7fe75b5d323a8e1b35710aafe41fdbf327b/yarl-1.18.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:6748dbf9bfa5ba1afcc7556b71cda0d7ce5f24768043a02a58846e4a443d808d", size = 362089 }, + { url = "https://files.pythonhosted.org/packages/57/cf/aadba261d8b920253204085268bad5e8cdd86b50162fcb1b10c10834885a/yarl-1.18.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0b0cad37311123211dc91eadcb322ef4d4a66008d3e1bdc404808992260e1a0e", size = 366267 }, + { url = "https://files.pythonhosted.org/packages/54/58/fb4cadd81acdee6dafe14abeb258f876e4dd410518099ae9a35c88d8097c/yarl-1.18.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0fb2171a4486bb075316ee754c6d8382ea6eb8b399d4ec62fde2b591f879778a", size = 359141 }, + { url = "https://files.pythonhosted.org/packages/9a/7a/4c571597589da4cd5c14ed2a0b17ac56ec9ee7ee615013f74653169e702d/yarl-1.18.3-cp311-cp311-win32.whl", hash = "sha256:61b1a825a13bef4a5f10b1885245377d3cd0bf87cba068e1d9a88c2ae36880e1", size = 84402 }, + { url = "https://files.pythonhosted.org/packages/ae/7b/8600250b3d89b625f1121d897062f629883c2f45339623b69b1747ec65fa/yarl-1.18.3-cp311-cp311-win_amd64.whl", hash = "sha256:b9d60031cf568c627d028239693fd718025719c02c9f55df0a53e587aab951b5", size = 91030 }, + { url = "https://files.pythonhosted.org/packages/33/85/bd2e2729752ff4c77338e0102914897512e92496375e079ce0150a6dc306/yarl-1.18.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1dd4bdd05407ced96fed3d7f25dbbf88d2ffb045a0db60dbc247f5b3c5c25d50", size = 142644 }, + { url = "https://files.pythonhosted.org/packages/ff/74/1178322cc0f10288d7eefa6e4a85d8d2e28187ccab13d5b844e8b5d7c88d/yarl-1.18.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7c33dd1931a95e5d9a772d0ac5e44cac8957eaf58e3c8da8c1414de7dd27c576", size = 94962 }, + { url = "https://files.pythonhosted.org/packages/be/75/79c6acc0261e2c2ae8a1c41cf12265e91628c8c58ae91f5ff59e29c0787f/yarl-1.18.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25b411eddcfd56a2f0cd6a384e9f4f7aa3efee14b188de13048c25b5e91f1640", size = 92795 }, + { url = "https://files.pythonhosted.org/packages/6b/32/927b2d67a412c31199e83fefdce6e645247b4fb164aa1ecb35a0f9eb2058/yarl-1.18.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:436c4fc0a4d66b2badc6c5fc5ef4e47bb10e4fd9bf0c79524ac719a01f3607c2", size = 332368 }, + { url = "https://files.pythonhosted.org/packages/19/e5/859fca07169d6eceeaa4fde1997c91d8abde4e9a7c018e371640c2da2b71/yarl-1.18.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e35ef8683211db69ffe129a25d5634319a677570ab6b2eba4afa860f54eeaf75", size = 342314 }, + { url = "https://files.pythonhosted.org/packages/08/75/76b63ccd91c9e03ab213ef27ae6add2e3400e77e5cdddf8ed2dbc36e3f21/yarl-1.18.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:84b2deecba4a3f1a398df819151eb72d29bfeb3b69abb145a00ddc8d30094512", size = 341987 }, + { url = "https://files.pythonhosted.org/packages/1a/e1/a097d5755d3ea8479a42856f51d97eeff7a3a7160593332d98f2709b3580/yarl-1.18.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e5a1fea0fd4f5bfa7440a47eff01d9822a65b4488f7cff83155a0f31a2ecba", size = 336914 }, + { url = "https://files.pythonhosted.org/packages/0b/42/e1b4d0e396b7987feceebe565286c27bc085bf07d61a59508cdaf2d45e63/yarl-1.18.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d0e883008013c0e4aef84dcfe2a0b172c4d23c2669412cf5b3371003941f72bb", size = 325765 }, + { url = "https://files.pythonhosted.org/packages/7e/18/03a5834ccc9177f97ca1bbb245b93c13e58e8225276f01eedc4cc98ab820/yarl-1.18.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5a3f356548e34a70b0172d8890006c37be92995f62d95a07b4a42e90fba54272", size = 344444 }, + { url = "https://files.pythonhosted.org/packages/c8/03/a713633bdde0640b0472aa197b5b86e90fbc4c5bc05b727b714cd8a40e6d/yarl-1.18.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ccd17349166b1bee6e529b4add61727d3f55edb7babbe4069b5764c9587a8cc6", size = 340760 }, + { url = "https://files.pythonhosted.org/packages/eb/99/f6567e3f3bbad8fd101886ea0276c68ecb86a2b58be0f64077396cd4b95e/yarl-1.18.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b958ddd075ddba5b09bb0be8a6d9906d2ce933aee81100db289badbeb966f54e", size = 346484 }, + { url = "https://files.pythonhosted.org/packages/8e/a9/84717c896b2fc6cb15bd4eecd64e34a2f0a9fd6669e69170c73a8b46795a/yarl-1.18.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c7d79f7d9aabd6011004e33b22bc13056a3e3fb54794d138af57f5ee9d9032cb", size = 359864 }, + { url = "https://files.pythonhosted.org/packages/1e/2e/d0f5f1bef7ee93ed17e739ec8dbcb47794af891f7d165fa6014517b48169/yarl-1.18.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4891ed92157e5430874dad17b15eb1fda57627710756c27422200c52d8a4e393", size = 364537 }, + { url = "https://files.pythonhosted.org/packages/97/8a/568d07c5d4964da5b02621a517532adb8ec5ba181ad1687191fffeda0ab6/yarl-1.18.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ce1af883b94304f493698b00d0f006d56aea98aeb49d75ec7d98cd4a777e9285", size = 357861 }, + { url = "https://files.pythonhosted.org/packages/7d/e3/924c3f64b6b3077889df9a1ece1ed8947e7b61b0a933f2ec93041990a677/yarl-1.18.3-cp312-cp312-win32.whl", hash = "sha256:f91c4803173928a25e1a55b943c81f55b8872f0018be83e3ad4938adffb77dd2", size = 84097 }, + { url = "https://files.pythonhosted.org/packages/34/45/0e055320daaabfc169b21ff6174567b2c910c45617b0d79c68d7ab349b02/yarl-1.18.3-cp312-cp312-win_amd64.whl", hash = "sha256:7e2ee16578af3b52ac2f334c3b1f92262f47e02cc6193c598502bd46f5cd1477", size = 90399 }, + { url = "https://files.pythonhosted.org/packages/f5/4b/a06e0ec3d155924f77835ed2d167ebd3b211a7b0853da1cf8d8414d784ef/yarl-1.18.3-py3-none-any.whl", hash = "sha256:b57f4f58099328dfb26c6a771d09fb20dbbae81d20cfb66141251ea063bd101b", size = 45109 }, ] [[package]] name = "youtube-transcript-api" -version = "1.1.0" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "defusedxml" }, { name = "requests" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/36/dd/10d413b20a2d14fa483853d0f6d920a0a0a6887d7c60167e4641733f99fb/youtube_transcript_api-1.1.0.tar.gz", hash = "sha256:786d9e64bd7fffee0dbc1471a61a798cebdc379b9cf8f7661d3664e831fcc1a5", size = 470144 } +sdist = { url = "https://files.pythonhosted.org/packages/eb/e5/226a09b9ca49136f901a969fd65bcd055eaa980fd04ac065dac4741e6b00/youtube_transcript_api-1.1.1.tar.gz", hash = "sha256:2e1162d45ece14223a58a4a39176c464fdd33d5ebdd6def18ebb038dea62f667", size = 470360 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/69/63f1b9f96a9d3b6bd35288fe27f987c41bd157e47b3d07ca025549e3f8e6/youtube_transcript_api-1.1.0-py3-none-any.whl", hash = "sha256:876ac42b1e3f8cc99b81d8fd810bd74ed07511e51dff5db50e714e3156ad3595", size = 485739 }, -] - -[[package]] -name = "zipp" -version = "3.23.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276 }, + { url = "https://files.pythonhosted.org/packages/a7/8a/b942a230084045da4a255bbebca97693569535670c0a23c09096881b2846/youtube_transcript_api-1.1.1-py3-none-any.whl", hash = "sha256:a438a824d67c0885855047e2b38993abdd4f59b69a983cf27b50a06c9d564064", size = 485906 }, ] [[package]]