diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 00000000..c8796346 --- /dev/null +++ b/.coveragerc @@ -0,0 +1,8 @@ +[run] +source = linkedin_mcp_server +branch = true +omit = linkedin_mcp_server/__main__.py + +[report] +fail_under = 45 +show_missing = true diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 00000000..a67e2756 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,164 @@ +# Based on .gitignore with Docker-specific additions + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pipenv +#Pipfile.lock + +# poetry +#poetry.lock + +# pdm +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582 +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + +# Cursor +.cursorignore +.cursorindexingignore +.cursor + +# Docker-specific exclusions +.git +.github +README.md +.DS_Store + +# DXT Extension +*.dxt +assets/* + +# other dev files +.vscode +.claude +.github +.docker diff --git a/.env.example b/.env.example new file mode 100644 index 00000000..8b17ca37 --- /dev/null +++ b/.env.example @@ -0,0 +1,38 @@ +# LinkedIn MCP Server Environment Variables +# Copy this file to .env and fill in your values + +# Persistent browser profile directory (default: ~/.linkedin-mcp/profile) +# Run with --login to create a profile via browser login +USER_DATA_DIR=~/.linkedin-mcp/profile + +# Browser mode (default: true) +# true = headless, false = visible window +HEADLESS=true + +# Logging level (default: WARNING) +# Options: DEBUG, INFO, WARNING, ERROR +LOG_LEVEL=WARNING + +# Transport mode (leave empty for interactive prompt, defaults to stdio in non-interactive) +# Options: stdio, streamable-http +TRANSPORT= + +# Browser timeout in milliseconds (default: 5000) +TIMEOUT=5000 + +# Custom browser user agent (optional) +USER_AGENT= + +# HTTP server settings (for streamable-http transport) +HOST=127.0.0.1 +PORT=8000 +HTTP_PATH=/mcp + +# Debugging options +# Slow down browser actions by this many milliseconds (default: 0) +SLOW_MO=0 +# Browser viewport size as WIDTHxHEIGHT (default: 1280x720) +VIEWPORT=1280x720 +# Custom Chrome/Chromium executable path (optional) +# Use this if Chrome is installed in a non-standard location +CHROME_PATH= diff --git a/.gemini/settings.json b/.gemini/settings.json new file mode 100644 index 00000000..eae4070e --- /dev/null +++ b/.gemini/settings.json @@ -0,0 +1,7 @@ +{ + "mcpServers": { + "linkedin-mcp-server": { + "httpUrl": "http://127.0.0.1:8000/mcp" + } + } +} diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 00000000..0ba70198 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,44 @@ +--- +name: Bug Report +about: Create a report to help us improve the LinkedIn MCP server +title: '[BUG] ' +labels: ['bug'] +assignees: '' + +--- + +## Installation Method +- [ ] Docker (specify docker image version/tag): _._._ +- [ ] Claude Desktop DXT extension (specify docker image version/tag): _._._ +- [ ] Local Python setup + +## When does the error occur? +- [ ] At startup +- [ ] During tool call (specify which tool): + - [ ] get_person_profile + - [ ] get_company_profile + - [ ] get_job_details + - [ ] search_jobs + - [ ] close_session + +## MCP Client Configuration + +**Claude Desktop Config** (`/Users/[username]/Library/Application Support/Claude/claude_desktop_config.json`): +```json +{ + "mcpServers": { + "linkedin": { + // Your configuration here (remove sensitive credentials) + } + } +} +``` + +## MCP Client Logs +**Claude Desktop Logs** (`/Users/[username]/Library/Logs/Claude/mcp-server-LinkedIn MCP Server.log`): +``` +Paste relevant log entries here +``` + +## Error Description +What went wrong and what did you expect to happen? diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 00000000..0e2cd75e --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,15 @@ +# .github/ISSUE_TEMPLATE/config.yml +blank_issues_enabled: false +contact_links: + - name: đŸ’Ŧ General Questions & Discussion + url: https://github.com/stickerdaniel/linkedin-mcp-server/discussions/categories/general-questions-discussion + about: Ask questions about setup, usage, or get help from the community + - name: 📚 Share Your Setup & Get Help with Configuration + url: https://github.com/stickerdaniel/linkedin-mcp-server/discussions/categories/share-your-setup-get-help-with-configuration + about: Share how you set up the MCP in your favorite client or get help with configuration + - name: 💡 Ideas & Suggestions + url: https://github.com/stickerdaniel/linkedin-mcp-server/discussions/categories/ideas-suggestions + about: Share ideas for new features or improvements (before creating a formal feature request) + - name: 🙌 Show and Tell + url: https://github.com/stickerdaniel/linkedin-mcp-server/discussions/categories/show-and-tell + about: I would love to see how you're using the LinkedIn MCP server and what you're building with it! diff --git a/.github/ISSUE_TEMPLATE/documentation_issue.md b/.github/ISSUE_TEMPLATE/documentation_issue.md new file mode 100644 index 00000000..816b05a3 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/documentation_issue.md @@ -0,0 +1,50 @@ +--- +name: Documentation Issue +about: Report problems with README, setup instructions, or other documentation +title: '[DOCS] ' +labels: ['documentation'] +assignees: '' + +--- + +## Documentation Problem +**What documentation issue did you find?** +- [ ] Incorrect/outdated setup instructions +- [ ] Missing information +- [ ] Unclear/confusing explanations +- [ ] Broken links +- [ ] Example code doesn't work +- [ ] Missing prerequisites +- [ ] Inconsistent information +- [ ] Typos/grammar issues +- [ ] Other: ___________ + +## Location +**Where is the documentation issue?** +- [ ] README.md +- [ ] Code comments +- [ ] Error messages +- [ ] CLI help text +- [ ] Other: ___________ + +**Specific section/line:** +___________ + +## Current Documentation +**What does the documentation currently say?** +``` +Paste the current text or link to the specific section +``` + +## Problem Description +**What's wrong or confusing about it?** +A clear description of why this documentation is problematic. + +## Suggested Fix +**What should it say instead?** +``` +Suggested replacement text or improvements +``` + +## Additional Context +Add any other context, screenshots, or examples that would help improve the documentation. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..31328c57 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature Request +about: Suggest an idea for the LinkedIn MCP server +title: '[FEATURE] ' +labels: ['enhancement'] +assignees: '' + +--- + +## Feature description +Describe what you want to happen. + +## Use case +Why this feature is useful. + +## Suggested implementation +If you have a specific idea for how to implement this feature, please describe it here. + +## Additional context +Add any other details that would help. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..4c8559fc --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,49 @@ +# .github/workflows/ci.yml +name: CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + lint-and-check: + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + + - name: Set up uv + uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7 + with: + enable-cache: true + + - name: Install dependencies + run: | + uv sync + uv sync --group dev + + - name: Run pre-commit hooks + uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1 + + - name: Optimize uv cache for CI + run: uv cache prune --ci + + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + + - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7 + with: + enable-cache: true + + - run: uv python install 3.14 + + - run: uv sync --group dev + + - name: Run tests + run: uv run pytest --cov --cov-report=term-missing -n auto -v -s + + - run: uv cache prune --ci diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml new file mode 100644 index 00000000..a59dcda6 --- /dev/null +++ b/.github/workflows/claude.yml @@ -0,0 +1,49 @@ +name: Claude Code + +on: + issue_comment: + types: [created] + pull_request_review_comment: + types: [created] + issues: + types: [opened, assigned] + pull_request_review: + types: [submitted] + +jobs: + claude: + if: | + (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) || + (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) || + (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) || + (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude'))) + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: read + issues: read + id-token: write + actions: read # Required for Claude to read CI results on PRs + steps: + - name: Checkout repository + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + with: + fetch-depth: 1 + + - name: Run Claude Code + id: claude + uses: anthropics/claude-code-action@df37d2f0760a4b5683a6e617c9325bc1a36443f6 # v1 + with: + claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }} + + # This is an optional setting that allows Claude to read CI results on PRs + additional_permissions: | + actions: read + + # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it. + # prompt: 'Update the pull request description to include a summary of changes.' + + # Optional: Add claude_args to customize behavior and configuration + # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md + # or https://code.claude.com/docs/en/cli-reference for available options + # claude_args: '--allowed-tools Bash(gh pr:*)' diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..5042d964 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,215 @@ +# .github/workflows/release.yml +name: Auto Release + +on: + push: + branches: [main] + paths: ['pyproject.toml'] # Only trigger when pyproject.toml changes + +jobs: + check-version-bump: + runs-on: ubuntu-latest + outputs: + should-release: ${{ steps.check.outputs.should-release }} + new-version: ${{ steps.check.outputs.new-version }} + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + with: + fetch-depth: 2 # Need to compare with previous commit + + - name: Set up uv + uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7 + with: + enable-cache: true + + - name: Check if version was bumped + id: check + run: | + # Get current version + CURRENT_VERSION=$(uv version | cut -d' ' -f2) + echo "Current version: $CURRENT_VERSION" + + # Get previous version from git (before this commit) + git checkout HEAD~1 -- pyproject.toml || true + PREVIOUS_VERSION=$(uv version | cut -d' ' -f2) 2>/dev/null || echo "0.0.0" + git checkout HEAD -- pyproject.toml + echo "Previous version: $PREVIOUS_VERSION" + + # Check if version actually changed + if [[ "$CURRENT_VERSION" != "$PREVIOUS_VERSION" ]]; then + echo "✅ Version bump detected: $PREVIOUS_VERSION → $CURRENT_VERSION" + echo "should-release=true" >> $GITHUB_OUTPUT + echo "new-version=$CURRENT_VERSION" >> $GITHUB_OUTPUT + else + echo "ℹī¸ No version change detected" + echo "should-release=false" >> $GITHUB_OUTPUT + fi + + release: + needs: check-version-bump + if: needs.check-version-bump.outputs.should-release == 'true' + runs-on: ubuntu-latest + env: + VERSION: ${{ needs.check-version-bump.outputs.new-version }} + permissions: + contents: write + packages: write + id-token: write # Required for PyPI Trusted Publishing + + steps: + - name: Checkout code + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6 + with: + fetch-depth: 0 + + - name: Set up uv + uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7 + with: + enable-cache: true + + - name: Set up Bun + uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2 + + - name: Update manifest.json and docker-compose.yml version + run: | + set -e + sed -i 's/"version": ".*"/"version": "'$VERSION'"/' manifest.json + sed -i 's/stickerdaniel\/linkedin-mcp-server:[^"]*/stickerdaniel\/linkedin-mcp-server:'$VERSION'/' manifest.json + sed -i 's/stickerdaniel\/linkedin-mcp-server:[^ ]*/stickerdaniel\/linkedin-mcp-server:'$VERSION'/' docker-compose.yml + echo "✅ Updated manifest.json and docker-compose.yml to version $VERSION" + + - name: Remove branch protection (temporary) + run: | + gh api repos/${{ github.repository }}/branches/main/protection \ + --method DELETE + env: + GH_TOKEN: ${{ secrets.GH_ADMIN_TOKEN }} + + - name: Commit version updates + run: | + set -e + git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com" + git config --local user.name "github-actions[bot]" + git add manifest.json docker-compose.yml + if git diff --staged --quiet; then + echo "ℹī¸ No changes to commit" + else + git commit -m "chore: update manifest.json and docker-compose.yml to v$VERSION [skip ci]" + git push origin main + echo "✅ Committed version updates" + fi + + - name: Restore branch protection + if: always() + env: + GH_TOKEN: ${{ secrets.GH_ADMIN_TOKEN }} + PAYLOAD: >- + { + "required_status_checks": { + "strict": true, + "checks": [ + {"context": "lint-and-check", "app_id": 15368}, + {"context": "test", "app_id": 15368} + ] + }, + "enforce_admins": true, + "required_pull_request_reviews": { + "dismiss_stale_reviews": false, + "require_code_owner_reviews": false, + "required_approving_review_count": 0 + }, + "restrictions": null + } + run: | + echo "$PAYLOAD" | gh api repos/${{ github.repository }}/branches/main/protection \ + --method PUT \ + --input - + + - name: Create release tag + run: | + set -e + git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com" + git config --local user.name "github-actions[bot]" + + if git tag -l "v$VERSION" | grep -q "v$VERSION"; then + echo "⚠ī¸ Tag v$VERSION already exists, skipping tag creation" + else + git tag "v$VERSION" + git push origin "v$VERSION" + echo "✅ Created and pushed tag v$VERSION" + fi + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4 + + - name: Log in to Docker Hub + uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + + - name: Build and push Docker images + uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7 + with: + context: . + push: true + tags: | + stickerdaniel/linkedin-mcp-server:${{ env.VERSION }} + stickerdaniel/linkedin-mcp-server:latest + platforms: linux/amd64,linux/arm64 + cache-from: type=gha + cache-to: type=gha,mode=max + + - name: Update Docker Hub description + uses: peter-evans/dockerhub-description@1b9a80c056b620d92cedb9d9b5a223409c68ddfa # v5 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + repository: stickerdaniel/linkedin-mcp-server + readme-filepath: docs/docker-hub.md + + - name: Optimize uv cache for CI + run: uv cache prune --ci + + - name: Build DXT extension + run: | + bunx @anthropic-ai/dxt pack + mv linkedin-mcp-server.dxt linkedin-mcp-server-v$VERSION.dxt + + - name: Generate release notes + run: | + envsubst < RELEASE_NOTES_TEMPLATE.md > RELEASE_NOTES.md + echo "✅ Generated release notes from template" + + - name: Create GitHub Release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + uses: softprops/action-gh-release@153bb8e04406b158c6c84fc1615b65b24149a1fe # v2 + with: + tag_name: v${{ env.VERSION }} + files: | + *.dxt + generate_release_notes: true + draft: false + prerelease: false + name: "LinkedIn MCP Server v${{ env.VERSION }}" + body_path: RELEASE_NOTES.md + + - name: Build package distributions + run: | + uv build + echo "Built package distributions:" + ls -lh dist/ + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + print-hash: true + verbose: true + + - name: Summary + run: | + echo "Successfully released v$VERSION!" + echo "Docker: stickerdaniel/linkedin-mcp-server:$VERSION" + echo "PyPI: https://pypi.org/project/linkedin-scraper-mcp/$VERSION/" + echo "GitHub: https://github.com/${{ github.repository }}/releases/tag/v$VERSION" diff --git a/.gitignore b/.gitignore index 505a3b1c..1f618bcc 100644 --- a/.gitignore +++ b/.gitignore @@ -1,10 +1,210 @@ -# Python-generated files +# Byte-compiled / optimized / DLL files __pycache__/ -*.py[oc] +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python build/ +develop-eggs/ dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ wheels/ -*.egg-info +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid -# Virtual environments +# SageMath parsed files +*.sage.py + +# Environments +.env .venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Visual Studio Code +# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore +# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore +# and can be added to the global gitignore or merged into this file. However, if you prefer, +# you could uncomment the following to ignore the enitre vscode folder +# .vscode/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + +# Cursor +# Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to +# exclude from AI features like autocomplete and code analysis. Recommended for sensitive data +# refer to https://docs.cursor.com/context/ignore-files +.cursorignore +.cursorindexingignore +.cursor + +# Docker deployment tracking +.docker/ + +# DXT extension packages (too large for git) +*.dxt + +# claude code settings +.claude + +# opencode +.opencode/plans + +# Portable cookie file (contains session data) +cookies.json + +# Local snapshot dumps (contain scraped LinkedIn data) +scripts/snapshot_dumps/ + +# Debug artifacts +.debug/ diff --git a/.mcp.json b/.mcp.json new file mode 100644 index 00000000..a6172ac0 --- /dev/null +++ b/.mcp.json @@ -0,0 +1,11 @@ +{ + "mcpServers": { + "greptile": { + "type": "http", + "url": "https://api.greptile.com/mcp", + "headers": { + "Authorization": "Bearer ${GREPTILE_API_KEY}" + } + } + } +} diff --git a/.opencode/agents/code-reviewer.md b/.opencode/agents/code-reviewer.md new file mode 100644 index 00000000..3ab541a3 --- /dev/null +++ b/.opencode/agents/code-reviewer.md @@ -0,0 +1,80 @@ +--- +name: code-reviewer +mode: subagent +# https://models.dev/ +model: 'openai/gpt-5.3-codex' +variant: 'high' +# model: 'github-copilot/gpt-5.3-codex' +color: '#22c55e' +description: | + Use this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes or creating pull requests. It will check for style violations, potential issues, and ensure code follows the established patterns in CLAUDE.md. Also the agent needs to know which files to focus on for the review. In most cases this will recently completed work which is unstaged in git (can be retrieved by doing a git diff). However there can be cases where this is different, make sure to specify this as the agent input when calling the agent. + + Examples: + + Context: The user has just implemented a new feature with several TypeScript files. + user: "I've added the new authentication feature. Can you check if everything looks good?" + assistant: "I'll use the Task tool to launch the code-reviewer agent to review your recent changes." + + Since the user has completed a feature and wants validation, use the code-reviewer agent to ensure the code meets project standards. + + + + Context: The assistant has just written a new utility function. + user: "Please create a function to validate email addresses" + assistant: "Here's the email validation function:" + + assistant: "Now I'll use the Task tool to launch the code-reviewer agent to review this implementation." + + Proactively use the code-reviewer agent after writing new code to catch issues early. + + + + Context: The user is about to create a PR. + user: "I think I'm ready to create a PR for this feature" + assistant: "Before creating the PR, I'll use the Task tool to launch the code-reviewer agent to ensure all code meets our standards." + + Proactively review code before PR creation to avoid review comments and iterations. + + +--- + +You are an expert code reviewer specializing in modern software development across multiple languages and frameworks. Your primary responsibility is to review code against project guidelines in CLAUDE.md with high precision to minimize false positives. + +## Review Scope + +By default, review unstaged changes from `git diff`. The user may specify different files or scope to review. + +## Core Review Responsibilities + +**Project Guidelines Compliance**: Verify adherence to explicit project rules (typically in CLAUDE.md or equivalent) including import patterns, framework conventions, language-specific style, function declarations, error handling, logging, testing practices, platform compatibility, and naming conventions. + +**Bug Detection**: Identify actual bugs that will impact functionality - logic errors, null/undefined handling, race conditions, memory leaks, security vulnerabilities, and performance problems. + +**Code Quality**: Evaluate significant issues like code duplication, missing critical error handling, accessibility problems, and inadequate test coverage. + +## Issue Confidence Scoring + +Rate each issue from 0-100: + +- **0-25**: Likely false positive or pre-existing issue +- **26-50**: Minor nitpick not explicitly in CLAUDE.md +- **51-75**: Valid but low-impact issue +- **76-90**: Important issue requiring attention +- **91-100**: Critical bug or explicit CLAUDE.md violation + +**Only report issues with confidence â‰Ĩ 80** + +## Output Format + +Start by listing what you're reviewing. For each high-confidence issue provide: + +- Clear description and confidence score +- File path and line number +- Specific CLAUDE.md rule or bug explanation +- Concrete fix suggestion + +Group issues by severity (Critical: 90-100, Important: 80-89). + +If no high-confidence issues exist, confirm the code meets standards with a brief summary. + +Be thorough but filter aggressively - quality over quantity. Focus on issues that truly matter. diff --git a/.opencode/agents/code-simplifier.md b/.opencode/agents/code-simplifier.md new file mode 100644 index 00000000..325929c4 --- /dev/null +++ b/.opencode/agents/code-simplifier.md @@ -0,0 +1,90 @@ +--- +name: code-simplifier +mode: subagent +# https://models.dev/ +model: 'openai/gpt-5.3-codex' +variant: 'high' +# model: 'github-copilot/gpt-5.3-codex' +color: '#3b82f6' +description: | + Use this agent when code has been written or modified and needs to be simplified for clarity, consistency, and maintainability while preserving all functionality. This agent should be triggered automatically after completing a coding task or writing a logical chunk of code. It simplifies code by following project best practices while retaining all functionality. The agent focuses only on recently modified code unless instructed otherwise. + + Examples: + + + Context: The assistant has just implemented a new feature that adds user authentication to an API endpoint. + user: "Please add authentication to the /api/users endpoint" + assistant: "I've implemented the authentication for the /api/users endpoint. Here's the code:" + + + Since a logical chunk of code has been written (authentication feature), use the Task tool to launch the code-simplifier agent to improve the code's clarity and maintainability while preserving functionality. + + assistant: "Now let me use the code-simplifier agent to refine this implementation for better clarity and maintainability" + + + + Context: The assistant has just fixed a bug by adding several conditional checks. + user: "Fix the null pointer exception in the data processor" + assistant: "I've added the necessary null checks to prevent the exception:" + + + After modifying code to fix a bug, use the code-simplifier agent to ensure the fix follows best practices and maintains code quality. + + assistant: "Let me refine this bug fix using the code-simplifier agent to ensure it follows our best practices" + + + + Context: The assistant has just refactored a function to improve performance. + user: "Optimize the data sorting algorithm for better performance" + assistant: "I've optimized the sorting algorithm. Here's the updated implementation:" + + + After completing a performance optimization task, use the code-simplifier agent to ensure the optimized code is also clear and maintainable. + + assistant: "Now I'll use the code-simplifier agent to ensure the optimized code is also clear and follows our coding standards" + +--- + +You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior. You prioritize readable, explicit code over overly compact solutions. This is a balance that you have mastered as a result your years as an expert software engineer. + +You will analyze recently modified code and apply refinements that: + +1. **Preserve Functionality**: Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact. + +2. **Apply Project Standards**: Follow the established coding standards from CLAUDE.md including: + - Use ES modules with proper import sorting and extensions + - Prefer `function` keyword over arrow functions + - Use explicit return type annotations for top-level functions + - Follow proper React component patterns with explicit Props types + - Use proper error handling patterns (avoid try/catch when possible) + - Maintain consistent naming conventions + +3. **Enhance Clarity**: Simplify code structure by: + - Reducing unnecessary complexity and nesting + - Eliminating redundant code and abstractions + - Improving readability through clear variable and function names + - Consolidating related logic + - Removing unnecessary comments that describe obvious code + - IMPORTANT: Avoid nested ternary operators - prefer switch statements or if/else chains for multiple conditions + - Choose clarity over brevity - explicit code is often better than overly compact code + +4. **Maintain Balance**: Avoid over-simplification that could: + - Reduce code clarity or maintainability + - Create overly clever solutions that are hard to understand + - Combine too many concerns into single functions or components + - Remove helpful abstractions that improve code organization + - Prioritize "fewer lines" over readability (e.g., nested ternaries, dense one-liners) + - Make the code harder to debug or extend + +5. **Focus Scope**: Only refine code that has been recently modified or touched in the current session, unless explicitly instructed to review a broader scope. + +Your refinement process: + +1. Identify the recently modified code sections +2. Analyze for opportunities to improve elegance and consistency +3. Apply project-specific best practices and coding standards +4. Ensure all functionality remains unchanged +5. Verify the refined code is simpler and more maintainable +6. Document only significant changes that affect understanding + +You operate autonomously and proactively, refining code immediately after it's written or modified without requiring explicit requests. Your goal is to ensure all code meets the highest standards of elegance and maintainability while preserving its complete functionality. diff --git a/.opencode/agents/comment-analyzer.md b/.opencode/agents/comment-analyzer.md new file mode 100644 index 00000000..d55b0b2c --- /dev/null +++ b/.opencode/agents/comment-analyzer.md @@ -0,0 +1,105 @@ +--- +name: comment-analyzer +mode: subagent +# https://models.dev/ +model: 'openai/gpt-5.3-codex' +variant: 'high' +# model: 'github-copilot/gpt-5.3-codex' +color: '#10b981' +description: | + Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability. This includes: (1) After generating large documentation comments or docstrings, (2) Before finalizing a pull request that adds or modifies comments, (3) When reviewing existing comments for potential technical debt or comment rot, (4) When you need to verify that comments accurately reflect the code they describe. + + + Context: The user is working on a pull request that adds several documentation comments to functions. + user: "I've added documentation to these functions. Can you check if the comments are accurate?" + assistant: "I'll use the comment-analyzer agent to thoroughly review all the comments in this pull request for accuracy and completeness." + + Since the user has added documentation comments and wants them checked, use the comment-analyzer agent to verify their accuracy against the actual code. + + + + + Context: The user just asked to generate comprehensive documentation for a complex function. + user: "Add detailed documentation for this authentication handler function" + assistant: "I've added the documentation. Now let me use the comment-analyzer agent to verify that the comments are accurate and helpful for long-term maintenance." + + After generating large documentation comments, proactively use the comment-analyzer to ensure quality. + + + + + Context: The user is preparing to create a pull request with multiple code changes and comments. + user: "I think we're ready to create the PR now" + assistant: "Before creating the pull request, let me use the comment-analyzer agent to review all the comments we've added or modified to ensure they're accurate and won't create technical debt." + + Before finalizing a PR, use the comment-analyzer to review all comment changes. + + +--- + +You are a meticulous code comment analyzer with deep expertise in technical documentation and long-term code maintainability. You approach every comment with healthy skepticism, understanding that inaccurate or outdated comments create technical debt that compounds over time. + +Your primary mission is to protect codebases from comment rot by ensuring every comment adds genuine value and remains accurate as code evolves. You analyze comments through the lens of a developer encountering the code months or years later, potentially without context about the original implementation. + +When analyzing comments, you will: + +1. **Verify Factual Accuracy**: Cross-reference every claim in the comment against the actual code implementation. Check: + - Function signatures match documented parameters and return types + - Described behavior aligns with actual code logic + - Referenced types, functions, and variables exist and are used correctly + - Edge cases mentioned are actually handled in the code + - Performance characteristics or complexity claims are accurate + +2. **Assess Completeness**: Evaluate whether the comment provides sufficient context without being redundant: + - Critical assumptions or preconditions are documented + - Non-obvious side effects are mentioned + - Important error conditions are described + - Complex algorithms have their approach explained + - Business logic rationale is captured when not self-evident + +3. **Evaluate Long-term Value**: Consider the comment's utility over the codebase's lifetime: + - Comments that merely restate obvious code should be flagged for removal + - Comments explaining 'why' are more valuable than those explaining 'what' + - Comments that will become outdated with likely code changes should be reconsidered + - Comments should be written for the least experienced future maintainer + - Avoid comments that reference temporary states or transitional implementations + +4. **Identify Misleading Elements**: Actively search for ways comments could be misinterpreted: + - Ambiguous language that could have multiple meanings + - Outdated references to refactored code + - Assumptions that may no longer hold true + - Examples that don't match current implementation + - TODOs or FIXMEs that may have already been addressed + +5. **Suggest Improvements**: Provide specific, actionable feedback: + - Rewrite suggestions for unclear or inaccurate portions + - Recommendations for additional context where needed + - Clear rationale for why comments should be removed + - Alternative approaches for conveying the same information + +Your analysis output should be structured as: + +**Summary**: Brief overview of the comment analysis scope and findings + +**Critical Issues**: Comments that are factually incorrect or highly misleading + +- Location: [file:line] +- Issue: [specific problem] +- Suggestion: [recommended fix] + +**Improvement Opportunities**: Comments that could be enhanced + +- Location: [file:line] +- Current state: [what's lacking] +- Suggestion: [how to improve] + +**Recommended Removals**: Comments that add no value or create confusion + +- Location: [file:line] +- Rationale: [why it should be removed] + +**Positive Findings**: Well-written comments that serve as good examples (if any) + +Remember: You are the guardian against technical debt from poor documentation. Be thorough, be skeptical, and always prioritize the needs of future maintainers. Every comment should earn its place in the codebase by providing clear, lasting value. + +IMPORTANT: You analyze and provide feedback only. Do not modify code or comments directly. Your role is advisory - to identify issues and suggest improvements for others to implement. diff --git a/.opencode/agents/pr-test-analyzer.md b/.opencode/agents/pr-test-analyzer.md new file mode 100644 index 00000000..76a8c726 --- /dev/null +++ b/.opencode/agents/pr-test-analyzer.md @@ -0,0 +1,102 @@ +--- +name: pr-test-analyzer +mode: subagent +# https://models.dev/ +model: 'openai/gpt-5.3-codex' +variant: 'high' +# model: 'github-copilot/gpt-5.3-codex' +color: '#06b6d4' +description: | + Use this agent when you need to review a pull request for test coverage quality and completeness. This agent should be invoked after a PR is created or updated to ensure tests adequately cover new functionality and edge cases. Examples: + + + Context: Daisy has just created a pull request with new functionality. + user: "I've created the PR. Can you check if the tests are thorough?" + assistant: "I'll use the pr-test-analyzer agent to review the test coverage and identify any critical gaps." + + Since Daisy is asking about test thoroughness in a PR, use the Task tool to launch the pr-test-analyzer agent. + + + + + Context: A pull request has been updated with new code changes. + user: "The PR is ready for review - I added the new validation logic we discussed" + assistant: "Let me analyze the PR to ensure the tests adequately cover the new validation logic and edge cases." + + The PR has new functionality that needs test coverage analysis, so use the pr-test-analyzer agent. + + + + + Context: Reviewing PR feedback before marking as ready. + user: "Before I mark this PR as ready, can you double-check the test coverage?" + assistant: "I'll use the pr-test-analyzer agent to thoroughly review the test coverage and identify any critical gaps before you mark it ready." + + Daisy wants a final test coverage check before marking PR ready, use the pr-test-analyzer agent. + + +--- + +You are an expert test coverage analyst specializing in pull request review. Your primary responsibility is to ensure that PRs have adequate test coverage for critical functionality without being overly pedantic about 100% coverage. + +**Your Core Responsibilities:** + +1. **Analyze Test Coverage Quality**: Focus on behavioral coverage rather than line coverage. Identify critical code paths, edge cases, and error conditions that must be tested to prevent regressions. + +2. **Identify Critical Gaps**: Look for: + - Untested error handling paths that could cause silent failures + - Missing edge case coverage for boundary conditions + - Uncovered critical business logic branches + - Absent negative test cases for validation logic + - Missing tests for concurrent or async behavior where relevant + +3. **Evaluate Test Quality**: Assess whether tests: + - Test behavior and contracts rather than implementation details + - Would catch meaningful regressions from future code changes + - Are resilient to reasonable refactoring + - Follow DAMP principles (Descriptive and Meaningful Phrases) for clarity + +4. **Prioritize Recommendations**: For each suggested test or modification: + - Provide specific examples of failures it would catch + - Rate criticality from 1-10 (10 being absolutely essential) + - Explain the specific regression or bug it prevents + - Consider whether existing tests might already cover the scenario + +**Analysis Process:** + +1. First, examine the PR's changes to understand new functionality and modifications +2. Review the accompanying tests to map coverage to functionality +3. Identify critical paths that could cause production issues if broken +4. Check for tests that are too tightly coupled to implementation +5. Look for missing negative cases and error scenarios +6. Consider integration points and their test coverage + +**Rating Guidelines:** + +- 9-10: Critical functionality that could cause data loss, security issues, or system failures +- 7-8: Important business logic that could cause user-facing errors +- 5-6: Edge cases that could cause confusion or minor issues +- 3-4: Nice-to-have coverage for completeness +- 1-2: Minor improvements that are optional + +**Output Format:** + +Structure your analysis as: + +1. **Summary**: Brief overview of test coverage quality +2. **Critical Gaps** (if any): Tests rated 8-10 that must be added +3. **Important Improvements** (if any): Tests rated 5-7 that should be considered +4. **Test Quality Issues** (if any): Tests that are brittle or overfit to implementation +5. **Positive Observations**: What's well-tested and follows best practices + +**Important Considerations:** + +- Focus on tests that prevent real bugs, not academic completeness +- Consider the project's testing standards from CLAUDE.md if available +- Remember that some code paths may be covered by existing integration tests +- Avoid suggesting tests for trivial getters/setters unless they contain logic +- Consider the cost/benefit of each suggested test +- Be specific about what each test should verify and why it matters +- Note when tests are testing implementation rather than behavior + +You are thorough but pragmatic, focusing on tests that provide real value in catching bugs and preventing regressions rather than achieving metrics. You understand that good tests are those that fail when behavior changes unexpectedly, not when implementation details change. diff --git a/.opencode/agents/silent-failure-hunter.md b/.opencode/agents/silent-failure-hunter.md new file mode 100644 index 00000000..7fafe9e9 --- /dev/null +++ b/.opencode/agents/silent-failure-hunter.md @@ -0,0 +1,167 @@ +--- +name: silent-failure-hunter +mode: subagent +# https://models.dev/ +model: 'openai/gpt-5.3-codex' +variant: 'high' +# model: 'github-copilot/gpt-5.3-codex' +color: '#eab308' +description: | + Use this agent when reviewing code changes in a pull request to identify silent failures, inadequate error handling, and inappropriate fallback behavior. This agent should be invoked proactively after completing a logical chunk of work that involves error handling, catch blocks, fallback logic, or any code that could potentially suppress errors. Examples: + + + Context: Daisy has just finished implementing a new feature that fetches data from an API with fallback behavior. + Daisy: "I've added error handling to the API client. Can you review it?" + Assistant: "Let me use the silent-failure-hunter agent to thoroughly examine the error handling in your changes." + + + + + Context: Daisy has created a PR with changes that include try-catch blocks. + Daisy: "Please review PR #1234" + Assistant: "I'll use the silent-failure-hunter agent to check for any silent failures or inadequate error handling in this PR." + + + + + Context: Daisy has just refactored error handling code. + Daisy: "I've updated the error handling in the authentication module" + Assistant: "Let me proactively use the silent-failure-hunter agent to ensure the error handling changes don't introduce silent failures." + + +--- + +You are an elite error handling auditor with zero tolerance for silent failures and inadequate error handling. Your mission is to protect users from obscure, hard-to-debug issues by ensuring every error is properly surfaced, logged, and actionable. + +## Core Principles + +You operate under these non-negotiable rules: + +1. **Silent failures are unacceptable** - Any error that occurs without proper logging and user feedback is a critical defect +2. **Users deserve actionable feedback** - Every error message must tell users what went wrong and what they can do about it +3. **Fallbacks must be explicit and justified** - Falling back to alternative behavior without user awareness is hiding problems +4. **Catch blocks must be specific** - Broad exception catching hides unrelated errors and makes debugging impossible +5. **Mock/fake implementations belong only in tests** - Production code falling back to mocks indicates architectural problems + +## Your Review Process + +When examining a PR, you will: + +### 1. Identify All Error Handling Code + +Systematically locate: + +- All try-catch blocks (or try-except in Python, Result types in Rust, etc.) +- All error callbacks and error event handlers +- All conditional branches that handle error states +- All fallback logic and default values used on failure +- All places where errors are logged but execution continues +- All optional chaining or null coalescing that might hide errors + +### 2. Scrutinize Each Error Handler + +For every error handling location, ask: + +**Logging Quality:** + +- Is the error logged with appropriate severity (logError for production issues)? +- Does the log include sufficient context (what operation failed, relevant IDs, state)? +- Is there an error ID from constants/errorIds.ts for Sentry tracking? +- Would this log help someone debug the issue 6 months from now? + +**User Feedback:** + +- Does the user receive clear, actionable feedback about what went wrong? +- Does the error message explain what the user can do to fix or work around the issue? +- Is the error message specific enough to be useful, or is it generic and unhelpful? +- Are technical details appropriately exposed or hidden based on the user's context? + +**Catch Block Specificity:** + +- Does the catch block catch only the expected error types? +- Could this catch block accidentally suppress unrelated errors? +- List every type of unexpected error that could be hidden by this catch block +- Should this be multiple catch blocks for different error types? + +**Fallback Behavior:** + +- Is there fallback logic that executes when an error occurs? +- Is this fallback explicitly requested by the user or documented in the feature spec? +- Does the fallback behavior mask the underlying problem? +- Would the user be confused about why they're seeing fallback behavior instead of an error? +- Is this a fallback to a mock, stub, or fake implementation outside of test code? + +**Error Propagation:** + +- Should this error be propagated to a higher-level handler instead of being caught here? +- Is the error being swallowed when it should bubble up? +- Does catching here prevent proper cleanup or resource management? + +### 3. Examine Error Messages + +For every user-facing error message: + +- Is it written in clear, non-technical language (when appropriate)? +- Does it explain what went wrong in terms the user understands? +- Does it provide actionable next steps? +- Does it avoid jargon unless the user is a developer who needs technical details? +- Is it specific enough to distinguish this error from similar errors? +- Does it include relevant context (file names, operation names, etc.)? + +### 4. Check for Hidden Failures + +Look for patterns that hide errors: + +- Empty catch blocks (absolutely forbidden) +- Catch blocks that only log and continue +- Returning null/undefined/default values on error without logging +- Using optional chaining (?.) to silently skip operations that might fail +- Fallback chains that try multiple approaches without explaining why +- Retry logic that exhausts attempts without informing the user + +### 5. Validate Against Project Standards + +Ensure compliance with the project's error handling requirements: + +- Never silently fail in production code +- Always log errors using appropriate logging functions +- Include relevant context in error messages +- Use proper error IDs for Sentry tracking +- Propagate errors to appropriate handlers +- Never use empty catch blocks +- Handle errors explicitly, never suppress them + +## Your Output Format + +For each issue you find, provide: + +1. **Location**: File path and line number(s) +2. **Severity**: CRITICAL (silent failure, broad catch), HIGH (poor error message, unjustified fallback), MEDIUM (missing context, could be more specific) +3. **Issue Description**: What's wrong and why it's problematic +4. **Hidden Errors**: List specific types of unexpected errors that could be caught and hidden +5. **User Impact**: How this affects the user experience and debugging +6. **Recommendation**: Specific code changes needed to fix the issue +7. **Example**: Show what the corrected code should look like + +## Your Tone + +You are thorough, skeptical, and uncompromising about error handling quality. You: + +- Call out every instance of inadequate error handling, no matter how minor +- Explain the debugging nightmares that poor error handling creates +- Provide specific, actionable recommendations for improvement +- Acknowledge when error handling is done well (rare but important) +- Use phrases like "This catch block could hide...", "Users will be confused when...", "This fallback masks the real problem..." +- Are constructively critical - your goal is to improve the code, not to criticize the developer + +## Special Considerations + +Be aware of project-specific patterns from CLAUDE.md: + +- This project has specific logging functions: logForDebugging (user-facing), logError (Sentry), logEvent (Statsig) +- Error IDs should come from constants/errorIds.ts +- The project explicitly forbids silent failures in production code +- Empty catch blocks are never acceptable +- Tests should not be fixed by disabling them; errors should not be fixed by bypassing them + +Remember: Every silent failure you catch prevents hours of debugging frustration for users and developers. Be thorough, be skeptical, and never let an error slip through unnoticed. diff --git a/.opencode/agents/type-design-analyzer.md b/.opencode/agents/type-design-analyzer.md new file mode 100644 index 00000000..746fef41 --- /dev/null +++ b/.opencode/agents/type-design-analyzer.md @@ -0,0 +1,134 @@ +--- +name: type-design-analyzer +mode: subagent +# https://models.dev/ +model: 'openai/gpt-5.3-codex' +variant: 'high' +# model: 'github-copilot/gpt-5.3-codex' +color: '#ec4899' +description: | + Use this agent when you need expert analysis of type design in your codebase. Specifically use it: (1) when introducing a new type to ensure it follows best practices for encapsulation and invariant expression, (2) during pull request creation to review all types being added, (3) when refactoring existing types to improve their design quality. The agent will provide both qualitative feedback and quantitative ratings on encapsulation, invariant expression, usefulness, and enforcement. + + + Context: Daisy is writing code that introduces a new UserAccount type and wants to ensure it has well-designed invariants. + user: "I've just created a new UserAccount type that handles user authentication and permissions" + assistant: "I'll use the type-design-analyzer agent to review the UserAccount type design" + + Since a new type is being introduced, use the type-design-analyzer to ensure it has strong invariants and proper encapsulation. + + + + + Context: Daisy is creating a pull request and wants to review all newly added types. + user: "I'm about to create a PR with several new data model types" + assistant: "Let me use the type-design-analyzer agent to review all the types being added in this PR" + + During PR creation with new types, use the type-design-analyzer to review their design quality. + + +--- + +You are a type design expert with extensive experience in large-scale software architecture. Your specialty is analyzing and improving type designs to ensure they have strong, clearly expressed, and well-encapsulated invariants. + +**Your Core Mission:** +You evaluate type designs with a critical eye toward invariant strength, encapsulation quality, and practical usefulness. You believe that well-designed types are the foundation of maintainable, bug-resistant software systems. + +**Analysis Framework:** + +When analyzing a type, you will: + +1. **Identify Invariants**: Examine the type to identify all implicit and explicit invariants. Look for: + - Data consistency requirements + - Valid state transitions + - Relationship constraints between fields + - Business logic rules encoded in the type + - Preconditions and postconditions + +2. **Evaluate Encapsulation** (Rate 1-10): + - Are internal implementation details properly hidden? + - Can the type's invariants be violated from outside? + - Are there appropriate access modifiers? + - Is the interface minimal and complete? + +3. **Assess Invariant Expression** (Rate 1-10): + - How clearly are invariants communicated through the type's structure? + - Are invariants enforced at compile-time where possible? + - Is the type self-documenting through its design? + - Are edge cases and constraints obvious from the type definition? + +4. **Judge Invariant Usefulness** (Rate 1-10): + - Do the invariants prevent real bugs? + - Are they aligned with business requirements? + - Do they make the code easier to reason about? + - Are they neither too restrictive nor too permissive? + +5. **Examine Invariant Enforcement** (Rate 1-10): + - Are invariants checked at construction time? + - Are all mutation points guarded? + - Is it impossible to create invalid instances? + - Are runtime checks appropriate and comprehensive? + +**Output Format:** + +Provide your analysis in this structure: + +``` +## Type: [TypeName] + +### Invariants Identified +- [List each invariant with a brief description] + +### Ratings +- **Encapsulation**: X/10 + [Brief justification] + +- **Invariant Expression**: X/10 + [Brief justification] + +- **Invariant Usefulness**: X/10 + [Brief justification] + +- **Invariant Enforcement**: X/10 + [Brief justification] + +### Strengths +[What the type does well] + +### Concerns +[Specific issues that need attention] + +### Recommended Improvements +[Concrete, actionable suggestions that won't overcomplicate the codebase] +``` + +**Key Principles:** + +- Prefer compile-time guarantees over runtime checks when feasible +- Value clarity and expressiveness over cleverness +- Consider the maintenance burden of suggested improvements +- Recognize that perfect is the enemy of good - suggest pragmatic improvements +- Types should make illegal states unrepresentable +- Constructor validation is crucial for maintaining invariants +- Immutability often simplifies invariant maintenance + +**Common Anti-patterns to Flag:** + +- Anemic domain models with no behavior +- Types that expose mutable internals +- Invariants enforced only through documentation +- Types with too many responsibilities +- Missing validation at construction boundaries +- Inconsistent enforcement across mutation methods +- Types that rely on external code to maintain invariants + +**When Suggesting Improvements:** + +Always consider: + +- The complexity cost of your suggestions +- Whether the improvement justifies potential breaking changes +- The skill level and conventions of the existing codebase +- Performance implications of additional validation +- The balance between safety and usability + +Think deeply about each type's role in the larger system. Sometimes a simpler type with fewer guarantees is better than a complex type that tries to do too much. Your goal is to help create types that are robust, clear, and maintainable without introducing unnecessary complexity. diff --git a/.opencode/commands/review.md b/.opencode/commands/review.md new file mode 100644 index 00000000..2ca1e0f4 --- /dev/null +++ b/.opencode/commands/review.md @@ -0,0 +1,207 @@ +--- +description: 'Comprehensive PR review using specialized agents' +argument-hint: '[review-aspects]' +allowed-tools: ['Bash', 'Glob', 'Grep', 'Read', 'Task'] +--- + +# Comprehensive PR Review + +Run a comprehensive pull request review using multiple specialized agents, each focusing on a different aspect of code quality. You can review in plan mode, the review doesnt require modifications until the user approves the final plan with the suggested fixes. + +**Review Aspects (optional):** "$ARGUMENTS" + +## Review Workflow: + +1. **Determine Review Scope** + - Check git status to identify changed files + - Parse arguments to see if user requested specific review aspects + - Default: Run all applicable reviews + +2. **Available Review Aspects:** + - **comments** - Analyze code comment accuracy and maintainability + - **tests** - Review test coverage quality and completeness + - **errors** - Check error handling for silent failures + - **types** - Analyze type design and invariants (if new types added) + - **code** - General code review for project guidelines + - **simplify** - Simplify code for clarity and maintainability + - **all** - Run all applicable reviews (default) + +3. **Identify Changed Files** + - Run `git diff --name-only` to see modified files + - Check if PR already exists: `gh pr view` + - Identify file types and what reviews apply + +4. **Determine Applicable Reviews** + + Based on changes: + - **Always applicable**: code-reviewer (general quality) + - **If test files changed**: pr-test-analyzer + - **If comments/docs added**: comment-analyzer + - **If error handling changed**: silent-failure-hunter + - **If types added/modified**: type-design-analyzer + - **After passing review**: code-simplifier (polish and refine) + +5. **Launch Review Agents** + + **Sequential approach** (user can request one at a time): + - Easier to understand and act on + - Each report is complete before next + - Good for interactive review + + **Parallel approach** (default): + - Launch all agents simultaneously + - Faster for comprehensive review + - Results come back together + +6. **Aggregate Results** + + After agents complete, summarize: + - **Critical Issues** (must fix before merge) + - **Important Issues** (should fix) + - **Suggestions** (nice to have) + - **Positive Observations** (what's good) + +7. **Provide Action Plan** + + Organize findings: + + ```markdown + # PR Review Summary + + ## Critical Issues (X found) + + - [agent-name]: Issue description [file:line] + + ## Important Issues (X found) + + - [agent-name]: Issue description [file:line] + + ## Suggestions (X found) + + - [agent-name]: Suggestion [file:line] + + ## Strengths + + - What's well-done in this PR + + ## Recommended Action + + 1. Fix critical issues first + 2. Address important issues + 3. Consider suggestions + 4. Re-run review after fixes + ``` + +## Usage Examples: + +**Full review (default):** + +``` +/review +``` + +**Specific aspects:** + +``` +/review tests errors +# Reviews only test coverage and error handling + +/review comments +# Reviews only code comments + +/review simplify +# Simplifies code after passing review +``` + +**Perpendicular review:** + +``` +/review all perpendicular +# Launches all agents after each other +``` + +## Agent Descriptions: + +**comment-analyzer**: + +- Verifies comment accuracy vs code +- Identifies comment rot +- Checks documentation completeness + +**pr-test-analyzer**: + +- Reviews behavioral test coverage +- Identifies critical gaps +- Evaluates test quality + +**silent-failure-hunter**: + +- Finds silent failures +- Reviews catch blocks +- Checks error logging + +**type-design-analyzer**: + +- Analyzes type encapsulation +- Reviews invariant expression +- Rates type design quality + +**code-reviewer**: + +- Checks AGENTS.md compliance +- Detects bugs and issues +- Reviews general code quality + +**code-simplifier**: + +- Simplifies complex code +- Improves clarity and readability +- Applies project standards +- Preserves functionality + +## Tips: + +- **Run early**: Before creating PR, not after +- **Focus on changes**: Agents analyze git diff by default +- **Address critical first**: Fix high-priority issues before lower priority +- **Re-run after fixes**: Verify issues are resolved +- **Use specific reviews**: Target specific aspects when you know the concern + +## Workflow Integration: + +**Before committing:** + +``` +1. Write code +2. Run: /review code errors +3. After review agents have finished, launch a general subagent for every critical / important issue found that should verify if this is indeed an issue and if it should be fixed. Instruct those general agents to use the tools available. For example, if it's a Svelte specific issue, it should use the Svelte MCP. If it's a Convex related issue, use the Convex mcp. +4. Enter plan mode if you arent already in it. Create a plan that addresses the issues and how to fix them. +5. User confirms the plan and fix the issues. +``` + +**Before creating PR:** + +``` +1. Stage all changes +2. Run: /review all +3. After review agents have finished, launch a general subagent for every critical / important issue found that should verify if this is indeed an issue and if it should be fixed. Instruct those general agents to use the tools available. For example, if it's a Svelte specific issue, it should use the Svelte MCP. If it's a Convex related issue, use the Convex mcp. +4. Create a plan that addresses the issues and how to fix them. +5. Run specific reviews again to verify +6. Create PR +``` + +**After PR feedback:** + +``` +1. Make requested changes +2. Run targeted reviews based on feedback +3. Verify issues are resolved +4. Push updates +``` + +## Notes + +- Agents run autonomously and return detailed reports +- Each agent focuses on its specialty for deep analysis +- Results are actionable with specific file:line references +- Agents use appropriate models for their complexity diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 33ab114b..1ee7ed44 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -5,6 +5,10 @@ repos: hooks: - id: trailing-whitespace - id: end-of-file-fixer + - id: check-yaml + - id: check-added-large-files + - id: check-merge-conflict + - id: debug-statements - repo: https://github.com/astral-sh/ruff-pre-commit # Ruff version. @@ -14,7 +18,11 @@ repos: args: [--fix] - id: ruff-format -- repo: https://github.com/pre-commit/mirrors-mypy - rev: v1.15.0 +- repo: local hooks: - - id: mypy + - id: ty + name: ty + entry: uv run ty check + language: system + types: [python] + pass_filenames: false diff --git a/.python-version b/.python-version index e4fba218..6324d401 100644 --- a/.python-version +++ b/.python-version @@ -1 +1 @@ -3.12 +3.14 diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..585aad76 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,28 @@ +{ + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.fixAll": "explicit", + "source.organizeImports": "explicit" + }, + "editor.defaultFormatter": "charliermarsh.ruff", + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.fixAll": "explicit", + "source.organizeImports.ruff": "explicit" + } + }, + "python.defaultInterpreterPath": ".venv/bin/python", + "python.terminal.activateEnvironment": true, + "yaml.schemas": { + "https://www.schemastore.org/github-issue-config.json": "file:///Users/daniel/Documents/development/python/linkedin-mcp-server/.github/ISSUE_TEMPLATE/config.yml" + }, + "cursorpyright.analysis.autoImportCompletions": true, + "cursorpyright.analysis.diagnosticMode": "workspace", + "cursorpyright.analysis.extraPaths": [ + "./linkedin_mcp_server" + ], + "cursorpyright.analysis.stubPath": "./linkedin_mcp_server", + "cursorpyright.analysis.typeCheckingMode": "off" +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json index adae2a55..5fc74bcd 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -2,14 +2,37 @@ "version": "2.0.0", "tasks": [ { - "label": "Run pre-commit", + "label": "bunx @modelcontextprotocol/inspector", + "detail": "Run the Model Context Protocol Inspector", "type": "shell", - "command": "uv", - "args": ["run", "pre-commit", "run", "--all-files"], + "command": "bunx", + "args": ["@modelcontextprotocol/inspector"], "group": { "kind": "test", "isDefault": true }, + "presentation": { + "reveal": "always", + "panel": "new", + "focus": true + }, + "problemMatcher": [] + }, + { + "label": "uv run pre-commit run --all-files", + "detail": "Run pre-commit hooks on all files", + "type": "shell", + "command": "uv", + "args": [ + "run", + "pre-commit", + "run", + "--all-files" + ], + "group": { + "kind": "test", + "isDefault": false + }, "presentation": { "reveal": "never", "panel": "new", @@ -18,13 +41,125 @@ "problemMatcher": [] }, { - "label": "Run main.py", + "label": "uv run -m linkedin_mcp_server --log-level DEBUG --no-headless", + "detail": "Run server in debug mode with visible browser window", "type": "shell", "command": "uv", - "args": ["run", "main.py"], + "args": [ + "run", + "-m", + "linkedin_mcp_server", + "--log-level", + "DEBUG", + "--no-headless" + ], "group": { "kind": "build", - "isDefault": true + "isDefault": false + }, + "presentation": { + "reveal": "always", + "panel": "new", + "focus": true + }, + "problemMatcher": [] + }, + { + "label": "uv run -m linkedin_mcp_server --no-headless", + "detail": "Run server with visible browser window", + "type": "shell", + "command": "uv", + "args": [ + "run", + "-m", + "linkedin_mcp_server", + "--no-headless" + ], + "group": { + "kind": "build" + }, + "presentation": { + "reveal": "always", + "panel": "new", + "focus": true + }, + "problemMatcher": [] + }, + { + "label": "uv run -m linkedin_mcp_server --no-headless --transport streamable-http", + "detail": "Start HTTP MCP server on localhost:8000/mcp", + "type": "shell", + "command": "uv", + "args": [ + "run", + "-m", + "linkedin_mcp_server", + "--no-headless", + "--transport", + "streamable-http" + ], + "isBackground": true, + "group": { + "kind": "build", + "isDefault": false + }, + "presentation": { + "reveal": "always", + "panel": "new", + "focus": true + }, + "problemMatcher": [] + }, + { + "label": "uv run -m linkedin_mcp_server --get-session", + "detail": "Login to LinkedIn and save session (opens visible browser)", + "type": "shell", + "command": "uv", + "args": [ + "run", + "-m", + "linkedin_mcp_server", + "--get-session" + ], + "group": { + "kind": "build", + "isDefault": false + }, + "presentation": { + "reveal": "always", + "panel": "new", + "focus": true + }, + "problemMatcher": [] + }, + { + "label": "tail -n 20 -F ~/Library/Logs/Claude/mcp*.log", + "detail": "Follow Claude Desktop MCP logs", + "type": "shell", + "command": "tail", + "args": [ + "-n", + "20", + "-F", + "~/Library/Logs/Claude/mcp*.log" + ], + "isBackground": true, + "presentation": { + "reveal": "always", + "panel": "new", + "focus": false + }, + "problemMatcher": [] + }, + { + "label": "bunx @anthropic-ai/dxt pack", + "detail": "Pack the DXT package", + "type": "shell", + "command": "bunx", + "args": ["@anthropic-ai/dxt", "pack"], + "group": { + "kind": "build", + "isDefault": false }, "presentation": { "reveal": "always", diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 00000000..1349b03d --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,108 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Development Commands + +- Use `uv` for dependency management: `uv sync` (dev: `uv sync --group dev`) +- Lint: `uv run ruff check .` (auto-fix with `--fix`) +- Format: `uv run ruff format .` +- Type check: `uv run ty check` (using ty, not mypy) +- Tests: `uv run pytest` (with coverage: `uv run pytest --cov`) +- Pre-commit: `uv run pre-commit install` then `uv run pre-commit run --all-files` +- Run server locally: `uv run -m linkedin_mcp_server --no-headless` +- Run via uvx (PyPI/package verification only): `uvx linkedin-scraper-mcp` +- Docker build: `docker build -t linkedin-mcp-server .` +- Install browser: `uv run patchright install chromium` + +## Scraping Rules + +- **One section = one navigation.** Each entry in `PERSON_SECTIONS` / `COMPANY_SECTIONS` (`scraping/fields.py`) maps to exactly one page navigation. Never combine multiple URLs behind a single section. +- **Minimize DOM dependence.** Prefer innerText and URL navigation over DOM selectors. When DOM access is unavoidable, use minimal generic selectors (`a[href*="/jobs/view/"]`) — never class names tied to LinkedIn's layout. + +## Tool Return Format + +All scraping tools return: `{url, sections: {name: raw_text}}`. + +Optional additional keys: +- `references: {section_name: [{kind, url, text?, context?}]}` — LinkedIn URLs are relative paths +- `section_errors: {section_name: {error_type, error_message, issue_template_path, runtime, ...}}` +- `unknown_sections: [name, ...]` +- `job_ids: [id, ...]` (search_jobs only) + +## Verifying Bug Reports + +Always verify scraping bugs end-to-end against live LinkedIn, not just code analysis. Use `uv run`, not `uvx`, so the running process reflects your workspace. Use `uvx` only for packaged distribution verification. For live Docker investigations, refresh the source session first with `uv run -m linkedin_mcp_server --login` before testing each materially different approach. Assume a valid login profile already exists at `~/.linkedin-mcp/profile/`. + +```bash +# Start server +uv run -m linkedin_mcp_server --transport streamable-http --log-level DEBUG + +# Initialize MCP session (grab Mcp-Session-Id from response headers) +curl -s -D /tmp/mcp-headers -X POST http://127.0.0.1:8000/mcp \ + -H "Content-Type: application/json" \ + -H "Accept: application/json, text/event-stream" \ + -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' + +# Extract the session ID from saved headers +SESSION_ID=$(grep -i 'Mcp-Session-Id' /tmp/mcp-headers | awk '{print $2}' | tr -d '\r') + +# Call a tool +curl -s -X POST http://127.0.0.1:8000/mcp \ + -H "Content-Type: application/json" \ + -H "Accept: application/json, text/event-stream" \ + -H "Mcp-Session-Id: $SESSION_ID" \ + -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_person_profile","arguments":{"linkedin_username":"williamhgates","sections":"posts"}}}' +``` + +## Release Process + +```bash +git checkout main && git pull +uv version --bump minor # or: major, patch — updates pyproject.toml AND uv.lock +gt create -m "chore: Bump version to X.Y.Z" +gt submit # merge PR to trigger release workflow +``` + +After the workflow completes, file a PR in the MCP registry to update the version. + +## Commit Messages + +- Follow conventional commits: `type(scope): subject` +- Types: feat, fix, docs, style, refactor, test, chore, perf, ci +- Keep subject <50 chars, imperative mood + +## Development Workflow + +Always read [`CONTRIBUTING.md`](CONTRIBUTING.md) before filing an issue or working on this repository. + +- Include the model used for code generation in PR descriptions (e.g. "Generated with Claude Opus 4.6") +- Include a short prompt from the user messages that reproduces the PR diff. This tells the maintainer what was intended, which is often more useful than reviewing the full diff. +- When implementing a new feature/fix: + 1. Check open issues. If no issue exists, create one following the issue template. + 2. Branch from `main`: `feature/issue-number-short-description` + 3. Implement and test + 4. Update README.md and docs/docker-hub.md if relevant + 5. Create a draft PR; only convert to regular PR when ready to merge + 6. Review with AI agents first, then manual review. Do not squash commits. + +## PR Reviews + +Greptile posts initial reviews as PR review comments, but follow-ups as **issue comments**. Always check both. + +```bash +gh api repos/{owner}/{repo}/pulls/{pr}/reviews # initial reviews +gh api repos/{owner}/{repo}/pulls/{pr}/comments # inline comments +gh api repos/{owner}/{repo}/issues/{pr}/comments # follow-up reviews +``` + +## btca + +When you need up-to-date information about technologies used in this project, use btca to query source repositories directly. + +**Available resources**: fastmcp, patchright, pytest, ruff, ty, uv, inquirer, pythonDotenv, pyperclip, preCommit + +```bash +btca ask -r -q "" +btca ask -r fastmcp -r patchright -q "How do I set up browser context with FastMCP tools?" +``` diff --git a/CLAUDE.md b/CLAUDE.md new file mode 120000 index 00000000..47dc3e3d --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1 @@ +AGENTS.md \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..c6e737f5 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,146 @@ +# Contributing + +Contributions are welcome! Please [open an issue](https://github.com/stickerdaniel/linkedin-mcp-server/issues) first to discuss the feature or bug fix before submitting a PR. + +## Development Setup + +See the [README](README.md#-local-setup-develop--contribute) for full setup instructions. + +```bash +git clone https://github.com/stickerdaniel/linkedin-mcp-server +cd linkedin-mcp-server +uv sync # Install dependencies +uv sync --group dev # Install dev dependencies +uv run pre-commit install # Set up pre-commit hooks +uv run patchright install chromium # Install browser +uv run pytest --cov # Run tests with coverage +``` + +## Architecture: One Section = One Navigation + +The scraping engine is built around a **one-section-one-navigation** design. Understanding this is key to contributing effectively. + +### Why This Design? + +AI assistants (LLMs) call our MCP tools. Each LinkedIn page navigation takes time and risks rate limits. By mapping each section to exactly one URL, the LLM can request only the sections it needs — skipping unnecessary navigations while still capturing all available info from each visited page via `innerText` extraction. + +### How It Works + +**Section config dicts** (`scraping/fields.py`) define which pages exist: + +```python +# Maps section name -> (url_suffix, is_overlay) +PERSON_SECTIONS: dict[str, tuple[str, bool]] = { + "main_profile": ("/", False), + "experience": ("/details/experience/", False), + "contact_info": ("/overlay/contact-info/", True), + "languages": ("/details/languages/", False), + # ... +} +``` + +The `is_overlay` boolean distinguishes modal overlays (like contact info) from full page navigations — overlays use a different extraction method that reads from the `` element. + +The extractor iterates the config dict directly, checking which sections the caller requested: + +```python +for section_name, (suffix, is_overlay) in PERSON_SECTIONS.items(): + if section_name not in requested: + continue + # navigate and extract... +``` + +**Return format** — all scraping tools return: + +```python +{"url": str, "sections": {name: raw_text}} +# Optional compact link metadata: +{"url": str, "sections": {name: raw_text}, "references": {section: [{kind, url, text?, context?}, ...]}} +# When unknown section names are provided: +{"url": str, "sections": {name: raw_text}, "unknown_sections": [name, ...]} +# search_jobs also returns: +{"url": str, "sections": {name: raw_text}, "job_ids": [id, ...]} +``` + +`sections` remains the main readable payload. `references` is a compact supplement for entity/article traversal. LinkedIn references are emitted as relative paths to minimize token use. + +## Checklist: Adding a New Section + +When adding a section to an existing tool (e.g., adding "certifications" to `get_person_profile`): + +### Code + +- [ ] Add entry to `PERSON_SECTIONS` or `COMPANY_SECTIONS` with `(url_suffix, is_overlay)` (`scraping/fields.py`) +- [ ] Update tool docstring with new section name (`tools/person.py` or `tools/company.py`) + +### Tests + +- [ ] Add to `test_expected_keys` (`tests/test_fields.py`) +- [ ] Add to `test_all_sections` parse test (`tests/test_fields.py`) +- [ ] Update `test_all_sections_visit_all_urls` — add section to set, update assertions (`tests/test_scraping.py`) +- [ ] Add dedicated navigation test (e.g., `test_certifications_visits_details_page`) (`tests/test_scraping.py`) + +### Docs + +- [ ] Update tool table in `README.md` +- [ ] Update features list in `docs/docker-hub.md` +- [ ] Update tools array/description in `manifest.json` + +### Verify + +- [ ] `uv run pytest --cov` +- [ ] `uv run ruff check . --fix && uv run ruff format .` +- [ ] `uv run pre-commit run --all-files` + +## Checklist: Adding a New Tool + +When adding an entirely new MCP tool (e.g., `search_companies`): + +### Code + +- [ ] Add extractor method to `LinkedInExtractor` if needed (`scraping/extractor.py`) +- [ ] Add or extend tool registration function (`tools/*.py`) +- [ ] Register tools in `create_mcp_server()` if new file (`server.py`) + +### Tests + +- [ ] Add mock method to `_make_mock_extractor` (`tests/test_tools.py`) +- [ ] Add tool-level test class/method (`tests/test_tools.py`) +- [ ] Add extractor-level tests if new method (`tests/test_scraping.py`) + +### Docs + +- [ ] Update tool table in `README.md` +- [ ] Update features list in `docs/docker-hub.md` +- [ ] Add tool to `tools` array in `manifest.json` + +### Verify + +- [ ] `uv run pytest --cov` +- [ ] `uv run ruff check . --fix && uv run ruff format .` +- [ ] `uv run pre-commit run --all-files` + +## Workflow + +1. [Open an issue](https://github.com/stickerdaniel/linkedin-mcp-server/issues) describing the feature or bug +2. Create a branch: `feature/-` or `fix/-` +3. Implement, test, and update docs (see checklists above) +4. Open a PR — AI agents review first, then manual review +5. Don't squash commits on merge + +## Scraping Philosophy: Minimize DOM Dependence + +This project favours **innerText extraction and URL navigation** over DOM selectors. LinkedIn's markup changes frequently — class names, `data-` attributes, and component structure are unstable. Our scraping engine is deliberately built to survive those changes: + +- **Prefer `innerText`** over `querySelector` / DOM walking for data extraction. +- **Prefer URL navigation** (e.g. `/details/experience/`) over clicking UI elements. +- **When DOM access is unavoidable** (e.g. extracting `href` attributes that don't appear in innerText, finding a scrollable container), keep selectors minimal and generic. Favour tag + attribute patterns (`a[href*="/jobs/view/"]`) over class names (`.jobs-search-results-list`). +- **Never scope queries to layout-specific containers** like `.jobs-search-results-list` — these break silently when LinkedIn redesigns. Use `main` as the broadest acceptable scope. +- **Document any DOM dependency** with a comment explaining why innerText/URL navigation isn't sufficient. + +## Code Style + +- **Commits:** conventional commits — `type(scope): subject` (see [CLAUDE.md](CLAUDE.md) for details) +- **Lint/format:** `uv run ruff check . --fix && uv run ruff format .` +- **Type check:** `uv run ty check` +- **Tests:** `uv run pytest --cov` diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..b88f9b15 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,37 @@ +# Use slim Python base instead of full Playwright image (saves ~300-400 MB) +# Only Chromium is installed, not Firefox/WebKit +FROM python:3.14-slim-bookworm@sha256:55e465cb7e50cd1d7217fcb5386aa87d0356ca2cd790872142ef68d9ef6812b4 + +# Install uv package manager +COPY --from=ghcr.io/astral-sh/uv:latest@sha256:3472e43b4e738cf911c99d41bb34331280efad54c73b1def654a6227bb59b2b4 /uv /uvx /bin/ + +# Create non-root user first (matching original pwuser from Playwright image) +RUN useradd -m -s /bin/bash pwuser + +# Set working directory and ownership +WORKDIR /app +RUN chown pwuser:pwuser /app + +# Copy project files with correct ownership +COPY --chown=pwuser:pwuser . /app + +# Install git (needed for git-based dependencies in pyproject.toml) +RUN apt-get update && apt-get install -y --no-install-recommends git && rm -rf /var/lib/apt/lists/* + +# Set browser install location (Patchright reads PLAYWRIGHT_BROWSERS_PATH internally) +ENV PLAYWRIGHT_BROWSERS_PATH=/opt/patchright +# Install dependencies, system libs for Chromium, and patched Chromium binary +RUN uv sync --frozen && \ + uv run patchright install-deps chromium && \ + uv run patchright install chromium && \ + chmod -R 755 /opt/patchright + +# Fix ownership of app directory (venv created by uv) +RUN chown -R pwuser:pwuser /app + +# Switch to non-root user +USER pwuser + +# Set entrypoint and default arguments +ENTRYPOINT ["uv", "run", "-m", "linkedin_mcp_server"] +CMD [] diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..d5d41d94 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2025 Daniel Sticker + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index e3434efc..ecc52cea 100644 --- a/README.md +++ b/README.md @@ -1,172 +1,547 @@ # LinkedIn MCP Server -A Model Context Protocol (MCP) server that enables interaction with LinkedIn through Claude and other AI assistants. This server allows you to scrape LinkedIn profiles, companies, jobs, and perform job searches. +

+ PyPI + CI Status + Release + License +

-## 📋 Features +Through this LinkedIn MCP server, AI assistants like Claude can connect to your LinkedIn. Access profiles and companies, search for jobs, or get job details. -- **Profile Scraping**: Get detailed information from LinkedIn profiles -- **Company Analysis**: Extract company information, including employees if desired -- **Job Search**: Search for jobs and get recommended positions +## Installation Methods -## 🔧 Installation +[![uvx](https://img.shields.io/badge/uvx-Quick_Install-de5fe9?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDEiIGhlaWdodD0iNDEiIHZpZXdCb3g9IjAgMCA0MSA0MSIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTS01LjI4NjE5ZS0wNiAwLjE2ODYyOUwwLjA4NDMwOTggMjAuMTY4NUwwLjE1MTc2MiAzNi4xNjgzQzAuMTYxMDc1IDM4LjM3NzQgMS45NTk0NyA0MC4xNjA3IDQuMTY4NTkgNDAuMTUxNEwyMC4xNjg0IDQwLjA4NEwzMC4xNjg0IDQwLjA0MThMMzEuMTg1MiA0MC4wMzc1QzMzLjM4NzcgNDAuMDI4MiAzNS4xNjgzIDM4LjIwMjYgMzUuMTY4MyAzNlYzNkwzNy4wMDAzIDM2TDM3LjAwMDMgMzkuOTk5Mkw0MC4xNjgzIDM5Ljk5OTZMMzkuOTk5NiAtOS45NDY1M2UtMDdMMjEuNTk5OCAwLjA3NzU2ODlMMjEuNjc3NCAxNi4wMTg1TDIxLjY3NzQgMjUuOTk5OEwyMC4wNzc0IDI1Ljk5OThMMTguMzk5OCAyNS45OTk4TDE4LjQ3NzQgMTYuMDMyTDE4LjM5OTggMC4wOTEwNTkzTC01LjI4NjE5ZS0wNiAwLjE2ODYyOVoiIGZpbGw9IiNERTVGRTkiLz4KPC9zdmc+Cg==)](#-uvx-setup-recommended---universal) +[![Docker](https://img.shields.io/badge/Docker-Universal_MCP-008fe2?style=for-the-badge&logo=docker&logoColor=008fe2)](#-docker-setup) +[![Install DXT Extension](https://img.shields.io/badge/Claude_Desktop_DXT-d97757?style=for-the-badge&logo=anthropic)](#-claude-desktop-dxt-extension) +[![Development](https://img.shields.io/badge/Development-Local-ffdc53?style=for-the-badge&logo=python&logoColor=ffdc53)](#-local-setup-develop--contribute) -### Prerequisites + -- Python 3.8 or higher -- Chrome browser installed -- ChromeDriver matching your Chrome version -- A LinkedIn account +## Usage Examples -### Step 1: Clone or Download the Repository +``` +Research the background of this candidate https://www.linkedin.com/in/stickerdaniel/ +``` + +``` +Get this company profile for partnership discussions https://www.linkedin.com/company/inframs/ +``` + +``` +Suggest improvements for my CV to target this job posting https://www.linkedin.com/jobs/view/4252026496 +``` + +``` +What has Anthropic been posting about recently? https://www.linkedin.com/company/anthropicresearch/ +``` + +## Features & Tool Status + +| Tool | Description | Status | +|------|-------------|--------| +| `get_person_profile` | Get profile info with explicit section selection (experience, education, interests, honors, languages, contact_info, posts) | Working | +| `get_company_profile` | Extract company information with explicit section selection (posts, jobs) | Working | +| `get_company_posts` | Get recent posts from a company's LinkedIn feed | Working | +| `search_jobs` | Search for jobs with keywords and location filters | Working | +| `search_people` | Search for people by keywords and location | Working | +| `get_job_details` | Get detailed information about a specific job posting | Working | +| `close_session` | Close browser session and clean up resources | Working | + +Tool responses keep readable `sections` text and may also include a compact `references` map keyed by section. Each reference includes a typed target, a relative LinkedIn path (or absolute external URL), and a short label/context when available. + +When one section fails but the overall tool call still completes, responses may also include `section_errors`. Each entry contains structured diagnostics for that section, including the error type/message, a compact runtime summary, trace/log locations, matching-open-issue hints when available, and the path to a generated issue-ready markdown report with the full session details. + +> [!IMPORTANT] +> **Breaking change:** LinkedIn recently made some changes to prevent scraping. The newest version uses [Patchright](https://github.com/Kaliiiiiiiiii-Vinyzu/patchright-python) with persistent browser profiles instead of Playwright with session files. Old `session.json` files and `LINKEDIN_COOKIE` env vars are no longer supported. Run `--login` again to create a new profile + cookie file that can be mounted in docker. 02/2026 + +
+
+ +## 🚀 uvx Setup (Recommended - Universal) + +**Prerequisites:** [Install uv](https://docs.astral.sh/uv/getting-started/installation/) and run `uvx patchright install chromium` to set up the browser. + +### Installation + +**Step 1: Create a session (first time only)** ```bash -git clone https://github.com/stickerdaniel/linkedin-mcp-server -cd linkedin-mcp-server +uvx linkedin-scraper-mcp --login +``` + +This opens a browser for you to log in manually (5 minute timeout for 2FA, captcha, etc.). The browser profile is saved to `~/.linkedin-mcp/profile/`. + +**Step 2: Client Configuration:** + +```json +{ + "mcpServers": { + "linkedin": { + "command": "uvx", + "args": ["linkedin-scraper-mcp"] + } + } +} ``` -Or download and extract the zip file. +> [!NOTE] +> Sessions may expire over time. If you encounter authentication issues, run `uvx linkedin-scraper-mcp --login` again + +### uvx Setup Help + +
+🔧 Configuration + +**Transport Modes:** -### Step 2: Set Up a Virtual Environment +- **Default (stdio)**: Standard communication for local MCP servers +- **Streamable HTTP**: For web-based MCP server +- If no transport is specified, the server defaults to `stdio` +- An interactive terminal without explicit transport shows a chooser prompt -Using `uv` (recommended): +**CLI Options:** + +- `--login` - Open browser to log in and save persistent profile +- `--no-headless` - Show browser window (useful for debugging scraping issues) +- `--log-level {DEBUG,INFO,WARNING,ERROR}` - Set logging level (default: WARNING) +- `--transport {stdio,streamable-http}` - Optional: force transport mode (default: stdio) +- `--host HOST` - HTTP server host (default: 127.0.0.1) +- `--port PORT` - HTTP server port (default: 8000) +- `--path PATH` - HTTP server path (default: /mcp) +- `--logout` - Clear stored LinkedIn browser profile +- `--timeout MS` - Browser timeout for page operations in milliseconds (default: 5000) +- `--user-data-dir PATH` - Path to persistent browser profile directory (default: ~/.linkedin-mcp/profile) +- `--chrome-path PATH` - Path to Chrome/Chromium executable (for custom browser installations) + +**Basic Usage Examples:** ```bash -# Install uv if you don't have it -curl -LsSf https://astral.sh/uv/install.sh | sh +# Create a session interactively +uvx linkedin-scraper-mcp --login -# Create and activate virtual environment -uv venv -source .venv/bin/activate # On macOS/Linux -# OR -.venv\Scripts\activate # On Windows +# Run with debug logging +uvx linkedin-scraper-mcp --log-level DEBUG ``` -### Step 3: Install Dependencies +**HTTP Mode Example (for web-based MCP clients):** -Using `uv`: +```bash +uvx linkedin-scraper-mcp --transport streamable-http --host 127.0.0.1 --port 8080 --path /mcp +``` + +Runtime server logs are emitted by FastMCP/Uvicorn. + +Tool calls are serialized within a single server process to protect the shared +LinkedIn browser session. Concurrent client requests queue instead of running in +parallel. Use `--log-level DEBUG` to see scraper lock wait/acquire/release logs. + +**Test with mcp inspector:** + +1. Install and run mcp inspector ```bunx @modelcontextprotocol/inspector``` +2. Click pre-filled token url to open the inspector in your browser +3. Select `Streamable HTTP` as `Transport Type` +4. Set `URL` to `http://localhost:8080/mcp` +5. Connect +6. Test tools + +
+ +
+❗ Troubleshooting + +**Installation issues:** + +- Ensure you have uv installed: `curl -LsSf https://astral.sh/uv/install.sh | sh` +- Check uv version: `uv --version` (should be 0.4.0 or higher) + +**Session issues:** + +- Browser profile is stored at `~/.linkedin-mcp/profile/` +- Make sure you have only one active LinkedIn session at a time + +**Login issues:** + +- LinkedIn may require a login confirmation in the LinkedIn mobile app for `--login` +- You might get a captcha challenge if you logged in frequently. Run `uvx linkedin-scraper-mcp --login` which opens a browser where you can solve it manually. + +**Timeout issues:** + +- If pages fail to load or elements aren't found, try increasing the timeout: `--timeout 10000` +- Users on slow connections may need higher values (e.g., 15000-30000ms) +- Can also set via environment variable: `TIMEOUT=10000` + +**Custom Chrome path:** + +- If Chrome is installed in a non-standard location, use `--chrome-path /path/to/chrome` +- Can also set via environment variable: `CHROME_PATH=/path/to/chrome` + +
+ +
+
+ +## đŸŗ Docker Setup + +**Prerequisites:** Make sure you have [Docker](https://www.docker.com/get-started/) installed and running. + +### Authentication + +Docker runs headless (no browser window), so you need to create a browser profile locally first and mount it into the container. + +**Step 1: Create profile on the host (one-time setup)** ```bash -uv add "mcp[cli]" selenium httpx inquirer pyperclip -uv add "git+https://github.com/stickerdaniel/linkedin_scraper.git" +uvx linkedin-scraper-mcp --login +``` + +This opens a browser window where you log in manually (5 minute timeout for 2FA, captcha, etc.). The browser profile and cookies are saved under `~/.linkedin-mcp/`. On startup, Docker derives a Linux browser profile from your host cookies and creates a fresh session each time. If you experience stability issues with Docker, consider using the [uvx setup](#-uvx-setup-recommended---universal) instead. + +**Step 2: Configure Claude Desktop with Docker** + +```json +{ + "mcpServers": { + "linkedin": { + "command": "docker", + "args": [ + "run", "--rm", "-i", + "-v", "~/.linkedin-mcp:/home/pwuser/.linkedin-mcp", + "stickerdaniel/linkedin-mcp-server:latest" + ] + } + } +} ``` -### Step 4: Install ChromeDriver +> [!NOTE] +> Docker creates a fresh session on each startup. Sessions may expire over time — run `uvx linkedin-scraper-mcp --login` again if you encounter authentication issues. + +> [!NOTE] +> **Why can't I run `--login` in Docker?** Docker containers don't have a display server. Create a profile on your host using the [uvx setup](#-uvx-setup-recommended---universal) and mount it into Docker. + +### Docker Setup Help -ChromeDriver is required for Selenium to interact with Chrome. You need to install the version that matches your Chrome browser. +
+🔧 Configuration -1. **Check your Chrome version**: - - Open Chrome and go to the menu (three dots) > Help > About Google Chrome - - Note the version number (e.g., 123.0.6312.87) +**Transport Modes:** -2. **Download matching ChromeDriver**: - - Go to [ChromeDriver Downloads](https://chromedriver.chromium.org/downloads) / [Chrome for Testing](https://googlechromelabs.github.io/chrome-for-testing/) (Chrome-Version 115+) - - Download the version that matches your Chrome version - - Extract the downloaded file +- **Default (stdio)**: Standard communication for local MCP servers +- **Streamable HTTP**: For a web-based MCP server +- If no transport is specified, the server defaults to `stdio` +- An interactive terminal without explicit transport shows a chooser prompt -3. **Make ChromeDriver accessible**: - - **Option 1**: Place it in a directory that's in your PATH (e.g., `/usr/local/bin` on macOS/Linux) - - **Option 2**: Set the CHROMEDRIVER environment variable to the path where you placed it: - ```bash - export CHROMEDRIVER=/path/to/chromedriver # macOS/Linux - # OR - set CHROMEDRIVER=C:\path\to\chromedriver.exe # Windows - ``` - - **Option 3**: The server will attempt to auto-detect or prompt you for the path when run +**CLI Options:** -## 🚀 Running the Server +- `--log-level {DEBUG,INFO,WARNING,ERROR}` - Set logging level (default: WARNING) +- `--transport {stdio,streamable-http}` - Optional: force transport mode (default: stdio) +- `--host HOST` - HTTP server host (default: 127.0.0.1) +- `--port PORT` - HTTP server port (default: 8000) +- `--path PATH` - HTTP server path (default: /mcp) +- `--logout` - Clear all stored LinkedIn auth state, including source and derived runtime profiles +- `--timeout MS` - Browser timeout for page operations in milliseconds (default: 5000) +- `--user-data-dir PATH` - Path to persistent browser profile directory (default: ~/.linkedin-mcp/profile) +- `--chrome-path PATH` - Path to Chrome/Chromium executable (rarely needed in Docker) -1. **Start the server once manually**: +> [!NOTE] +> `--login` and `--no-headless` are not available in Docker (no display server). Use the [uvx setup](#-uvx-setup-recommended---universal) to create profiles. + +**HTTP Mode Example (for web-based MCP clients):** ```bash -# Using uv (recommended) -uv run main.py --no-lazy-init --no-headless +docker run -it --rm \ + -v ~/.linkedin-mcp:/home/pwuser/.linkedin-mcp \ + -p 8080:8080 \ + stickerdaniel/linkedin-mcp-server:latest \ + --transport streamable-http --host 0.0.0.0 --port 8080 --path /mcp ``` -2. **Lazy initialization (default behavior)**: - - The server uses lazy initialization, meaning it will only create the Chrome driver and log in when a tool is actually used - - You can set environment variables for non-interactive use: - ```bash - export LINKEDIN_EMAIL=your.email@example.com - export LINKEDIN_PASSWORD=your_password - ``` +Runtime server logs are emitted by FastMCP/Uvicorn. + +**Test with mcp inspector:** + +1. Install and run mcp inspector ```bunx @modelcontextprotocol/inspector``` +2. Click pre-filled token url to open the inspector in your browser +3. Select `Streamable HTTP` as `Transport Type` +4. Set `URL` to `http://localhost:8080/mcp` +5. Connect +6. Test tools + +
+ +
+❗ Troubleshooting -3. **Configure Claude Desktop**: - - The server will display and copy to your clipboard the configuration needed for Claude Desktop - - Open Claude Desktop and go to Settings > Developer > Edit Config - - Paste the configuration provided by the server - - Edit the configuration to include your LinkedIn credentials as environment variables +**Docker issues:** + +- Make sure [Docker](https://www.docker.com/get-started/) is installed +- Check if Docker is running: `docker ps` + +**Login issues:** + +- Make sure you have only one active LinkedIn session at a time +- LinkedIn may require a login confirmation in the LinkedIn mobile app for `--login` +- You might get a captcha challenge if you logged in frequently. Run `uvx linkedin-scraper-mcp --login` which opens a browser where you can solve captchas manually. See the [uvx setup](#-uvx-setup-recommended---universal) for prerequisites. +- If Docker auth becomes stale after you re-login on the host, restart Docker once so it can fresh-bridge from the new source session generation. + +**Timeout issues:** + +- If pages fail to load or elements aren't found, try increasing the timeout: `--timeout 10000` +- Users on slow connections may need higher values (e.g., 15000-30000ms) +- Can also set via environment variable: `TIMEOUT=10000` + +**Custom Chrome path:** + +- If Chrome is installed in a non-standard location, use `--chrome-path /path/to/chrome` +- Can also set via environment variable: `CHROME_PATH=/path/to/chrome` + +
+ +
+🔐 Remote Deployment with OAuth + +When deploying the server remotely (e.g. on Cloud Run, Fly.io, Railway), +enable OAuth 2.1 to protect the MCP endpoint. + +**Quick Start:** + +```bash +docker run --rm -i \ + -v ${HOME}/.linkedin-mcp:/home/pwuser/.linkedin-mcp \ + -e TRANSPORT=streamable-http \ + -e HOST=0.0.0.0 \ + -e AUTH=oauth \ + -e OAUTH_BASE_URL=https://your-server.example.com \ + -e OAUTH_PASSWORD=your-secret-password \ + -p 8000:8000 \ + stickerdaniel/linkedin-mcp-server +``` + +**Adding as a Claude.ai Custom Connector:** + +1. Deploy the server with OAuth enabled +2. In claude.ai, go to **Settings → Connectors → Add custom connector** +3. Enter the **full MCP endpoint URL** including `/mcp`: + `https://your-server.example.com/mcp` + > **Important:** Use the `/mcp` path, not the base URL — claude.ai will return "no tools" if you omit it. +4. Claude.ai will discover the OAuth endpoints automatically +5. You'll be redirected to the login page — enter your `OAUTH_PASSWORD` +6. The connection is now authenticated + +**Retrieving the OAuth password (if stored in GCP Secret Manager):** + +```bash +gcloud secrets versions access latest --secret=linkedin-mcp-oauth-password --project=YOUR_PROJECT +``` + +**Environment Variables:** + +| Variable | Description | +|----------|-------------| +| `AUTH` | Set to `oauth` to enable OAuth 2.1 authentication | +| `OAUTH_BASE_URL` | Public URL of your server (e.g. `https://my-mcp.example.com`) | +| `OAUTH_PASSWORD` | Password for the OAuth login page | + +**CLI Flags:** + +| Flag | Description | +|------|-------------| +| `--auth oauth` | Enable OAuth 2.1 authentication | +| `--oauth-base-url URL` | Public URL of your server | +| `--oauth-password PASSWORD` | Password for the login page | + +> **Note:** OAuth state is stored in-memory. Deploy with a single instance (`--max-instances 1` on Cloud Run) — multi-instance setups will break the login flow because `/authorize` and `/login` may land on different instances. + +
+ +
+
+ +## đŸ“Ļ Claude Desktop (DXT Extension) + +**Prerequisites:** [Claude Desktop](https://claude.ai/download) and [Docker](https://www.docker.com/get-started/) installed & running + +**One-click installation** for Claude Desktop users: + +1. Download the [DXT extension](https://github.com/stickerdaniel/linkedin-mcp-server/releases/latest) +2. Double-click to install into Claude Desktop +3. Create a session: `uvx linkedin-scraper-mcp --login` + +> [!NOTE] +> Sessions may expire over time. If you encounter authentication issues, run `uvx linkedin-scraper-mcp --login` again. + +### DXT Extension Setup Help + +
+❗ Troubleshooting + +**First-time setup timeout:** + +- Claude Desktop has a ~60 second connection timeout +- If the Docker image isn't cached, the pull may exceed this timeout +- **Fix:** Pre-pull the image before first use: + + ```bash + docker pull stickerdaniel/linkedin-mcp-server:2.3.0 + ``` + +- Then restart Claude Desktop + +**Docker issues:** + +- Make sure [Docker](https://www.docker.com/get-started/) is installed +- Check if Docker is running: `docker ps` + +**Login issues:** + +- Make sure you have only one active LinkedIn session at a time +- LinkedIn may require a login confirmation in the LinkedIn mobile app for `--login` +- You might get a captcha challenge if you logged in frequently. Run `uvx linkedin-scraper-mcp --login` which opens a browser where you can solve captchas manually. See the [uvx setup](#-uvx-setup-recommended---universal) for prerequisites. + +**Timeout issues:** + +- If pages fail to load or elements aren't found, try increasing the timeout: `--timeout 10000` +- Users on slow connections may need higher values (e.g., 15000-30000ms) +- Can also set via environment variable: `TIMEOUT=10000` + +
+ +
+
+ +## 🐍 Local Setup (Develop & Contribute) + +Contributions are welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for architecture guidelines and checklists. Please [open an issue](https://github.com/stickerdaniel/linkedin-mcp-server/issues) first to discuss the feature or bug fix before submitting a PR. + +**Prerequisites:** [Git](https://git-scm.com/downloads) and [uv](https://docs.astral.sh/uv/) installed + +### Installation + +```bash +# 1. Clone repository +git clone https://github.com/stickerdaniel/linkedin-mcp-server +cd linkedin-mcp-server + +# 2. Install UV package manager (if not already installed) +curl -LsSf https://astral.sh/uv/install.sh | sh + +# 3. Install dependencies +uv sync +uv sync --group dev + +# 4. Install Patchright browser +uv run patchright install chromium + +# 5. Install pre-commit hooks +uv run pre-commit install + +# 6. Create a session (first time only) +uv run -m linkedin_mcp_server --login + +# 7. Start the server +uv run -m linkedin_mcp_server +``` + +### Local Setup Help + +
+🔧 Configuration + +**CLI Options:** + +- `--login` - Open browser to log in and save persistent profile +- `--no-headless` - Show browser window (useful for debugging scraping issues) +- `--log-level {DEBUG,INFO,WARNING,ERROR}` - Set logging level (default: WARNING) +- `--transport {stdio,streamable-http}` - Optional: force transport mode (default: stdio) +- `--host HOST` - HTTP server host (default: 127.0.0.1) +- `--port PORT` - HTTP server port (default: 8000) +- `--path PATH` - HTTP server path (default: /mcp) +- `--logout` - Clear stored LinkedIn browser profile +- `--timeout MS` - Browser timeout for page operations in milliseconds (default: 5000) +- `--status` - Check if current session is valid and exit +- `--user-data-dir PATH` - Path to persistent browser profile directory (default: ~/.linkedin-mcp/profile) +- `--slow-mo MS` - Delay between browser actions in milliseconds (default: 0, useful for debugging) +- `--user-agent STRING` - Custom browser user agent +- `--viewport WxH` - Browser viewport size (default: 1280x720) +- `--chrome-path PATH` - Path to Chrome/Chromium executable (for custom browser installations) +- `--help` - Show help + +> **Note:** Most CLI options have environment variable equivalents. See `.env.example` for details. + +**HTTP Mode Example (for web-based MCP clients):** + +```bash +uv run -m linkedin_mcp_server --transport streamable-http --host 127.0.0.1 --port 8000 --path /mcp +``` + +**Claude Desktop:** -Example Claude Desktop configuration: ```json { "mcpServers": { - "linkedin-scraper": { - "command": "/path/to/uv", - "args": ["--directory", "/path/to/project", "run", "main.py", "--no-setup"], - "env": { - "LINKEDIN_EMAIL": "your.email@example.com", - "LINKEDIN_PASSWORD": "your_password" - } + "linkedin": { + "command": "uv", + "args": ["--directory", "/path/to/linkedin-mcp-server", "run", "-m", "linkedin_mcp_server"] } } } ``` -## 🔄 Using with Claude Desktop +`stdio` is used by default for this config. -1. **After adding the configuration** to Claude Desktop, restart the application -2. **Start a conversation** with Claude -3. **You'll see tools available** in the tools menu (hammer icon) -4. **You can now ask Claude** to retrieve LinkedIn profiles, search for jobs, etc. +
-Examples of what you can ask Claude: -- "Can you tell me about Daniels work experience? His LinkedIn profile is https://www.linkedin.com/in/stickerdaniel/" -- "Search for machine learning engineer jobs on LinkedIn" -- "Tell me about Google as a company based on their LinkedIn page" +
+❗ Troubleshooting -## 🔐 Security and Privacy +**Login issues:** -- Your LinkedIn credentials can be provided through environment variables or stored locally at `~/.linkedin_mcp_credentials.json` with user-only permissions -- Credentials are never exposed to Claude or any other AI and are only used for the LinkedIn login to scrape data -- The server runs on your local machine, not in the cloud -- All LinkedIn scraping happens through your account - be aware that profile visits are visible to other users +- Make sure you have only one active LinkedIn session at a time +- LinkedIn may require a login confirmation in the LinkedIn mobile app for `--login` +- You might get a captcha challenge if you logged in frequently. The `--login` command opens a browser where you can solve it manually. -## ⚠ī¸ Troubleshooting +**Scraping issues:** -### ChromeDriver Issues +- Use `--no-headless` to see browser actions and debug scraping problems +- Add `--log-level DEBUG` to see more detailed logging -If you encounter ChromeDriver errors: -1. Ensure your Chrome browser is updated -2. Download the matching ChromeDriver version -3. Set the CHROMEDRIVER path correctly -4. Try running with administrator/sudo privileges if permission issues occur +**Session issues:** -### Authentication Issues +- Browser profile is stored at `~/.linkedin-mcp/profile/` +- Use `--logout` to clear the profile and start fresh -If login fails: -1. Verify your LinkedIn credentials -2. Check if your account has two-factor authentication enabled -3. Try logging in manually to LinkedIn first, then run the server -4. Check your LinkedIn mobile app for a login request after running the server -5. Try to run the server with `--no-headless` to see where the login fails -6. Try to run the server with `--debug` to see more detailed logs +**Python/Patchright issues:** -### Connection Issues +- Check Python version: `python --version` (should be 3.12+) +- Reinstall Patchright: `uv run patchright install chromium` +- Reinstall dependencies: `uv sync --reinstall` -If Claude cannot connect to the server: -1. Ensure the server is running when you start it manually -2. Verify the configuration in Claude Desktop is correct -3. Restart Claude Desktop +**Timeout issues:** -## License +- If pages fail to load or elements aren't found, try increasing the timeout: `--timeout 10000` +- Users on slow connections may need higher values (e.g., 15000-30000ms) +- Can also set via environment variable: `TIMEOUT=10000` + +**Custom Chrome path:** + +- If Chrome is installed in a non-standard location, use `--chrome-path /path/to/chrome` +- Can also set via environment variable: `CHROME_PATH=/path/to/chrome` -This project is licensed under the MIT License - see the LICENSE file for details. +
+ + +
+
## Acknowledgements -- Based on the [LinkedIn Scraper](https://github.com/joeyism/linkedin_scraper) by joeyism -- Uses the Model Context Protocol (MCP) for integration with AI assistants +Built with [FastMCP](https://gofastmcp.com/) and [Patchright](https://github.com/Kaliiiiiiiiii-Vinyzu/patchright-python). + +Use in accordance with [LinkedIn's Terms of Service](https://www.linkedin.com/legal/user-agreement). Web scraping may violate LinkedIn's terms. This tool is for personal use only. + +## License ---- +This project is licensed under the Apache 2.0 license. -**Note**: This tool is for personal use only. Use responsibly and in accordance with LinkedIn's terms of service. Web scraping may violate LinkedIn's terms of service in some cases. +
diff --git a/RELEASE_NOTES_TEMPLATE.md b/RELEASE_NOTES_TEMPLATE.md new file mode 100644 index 00000000..9b240fb1 --- /dev/null +++ b/RELEASE_NOTES_TEMPLATE.md @@ -0,0 +1,24 @@ +For an installation guide, refer to the [README](https://github.com/stickerdaniel/linkedin-mcp-server/blob/main/README.md). + +## đŸŗ Update Docker Installation +**For users with Docker-based MCP client configurations:** +```bash +docker pull stickerdaniel/linkedin-mcp-server:latest +``` +The `latest` tag will always point to the most recent release. +To pull this specific version, run: +```bash +docker pull stickerdaniel/linkedin-mcp-server:${VERSION} +``` + +## đŸ“Ļ Update DXT Extension Installation +**For Claude Desktop users:** +1. Download the `.dxt` file below +2. Pre-pull the Docker image to avoid timeout issues: + ```bash + docker pull stickerdaniel/linkedin-mcp-server:${VERSION} + ``` +3. Double-click the `.dxt` file to install in Claude Desktop +4. Restart Claude Desktop + +> **Note:** The pre-pull step is important because Claude Desktop has a ~60 second connection timeout. Without pre-pulling, the initial image download may exceed this limit. diff --git a/assets/icons/linkedin.svg b/assets/icons/linkedin.svg new file mode 100644 index 00000000..4d5b353c --- /dev/null +++ b/assets/icons/linkedin.svg @@ -0,0 +1 @@ + diff --git a/assets/screenshots/screenshot.png b/assets/screenshots/screenshot.png new file mode 100644 index 00000000..935ac47e Binary files /dev/null and b/assets/screenshots/screenshot.png differ diff --git a/btca.config.jsonc b/btca.config.jsonc new file mode 100644 index 00000000..269e4202 --- /dev/null +++ b/btca.config.jsonc @@ -0,0 +1,78 @@ +{ + "$schema": "https://btca.dev/btca.schema.json", + "providerTimeoutMs": 300000, + "resources": [ + { + "type": "git", + "name": "fastmcp", + "url": "https://github.com/jlowin/fastmcp", + "branch": "main", + "specialNotes": "FastMCP server framework. Primary MCP library used in this project." + }, + { + "type": "git", + "name": "playwright", + "url": "https://github.com/microsoft/playwright-python", + "branch": "main", + "specialNotes": "Playwright Python bindings for browser automation." + }, + { + "type": "git", + "name": "pytest", + "url": "https://github.com/pytest-dev/pytest", + "branch": "main", + "specialNotes": "Python testing framework." + }, + { + "type": "git", + "name": "ruff", + "url": "https://github.com/astral-sh/ruff", + "branch": "main", + "specialNotes": "Fast Python linter and formatter written in Rust." + }, + { + "type": "git", + "name": "ty", + "url": "https://github.com/astral-sh/ty", + "branch": "main", + "specialNotes": "Fast Python type checker from Astral, written in Rust." + }, + { + "type": "git", + "name": "uv", + "url": "https://github.com/astral-sh/uv", + "branch": "main", + "specialNotes": "Fast Python package manager from Astral, written in Rust." + }, + { + "type": "git", + "name": "inquirer", + "url": "https://github.com/magmax/python-inquirer", + "branch": "master", + "specialNotes": "Python library for CLI interactive prompts." + }, + { + "type": "git", + "name": "pythonDotenv", + "url": "https://github.com/theskumar/python-dotenv", + "branch": "main", + "specialNotes": "Python library for loading .env files." + }, + { + "type": "git", + "name": "pyperclip", + "url": "https://github.com/asweigart/pyperclip", + "branch": "master", + "specialNotes": "Cross-platform Python clipboard module." + }, + { + "type": "git", + "name": "preCommit", + "url": "https://github.com/pre-commit/pre-commit", + "branch": "main", + "specialNotes": "Framework for managing pre-commit hooks." + } + ], + "model": "claude-haiku-4.5", + "provider": "github-copilot" +} diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 00000000..47e5778a --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,9 @@ +services: + linkedin-mcp: + image: stickerdaniel/linkedin-mcp-server:4.4.1 + volumes: + - ~/.linkedin-mcp:/home/pwuser/.linkedin-mcp + environment: + - LOG_LEVEL=WARNING + stdin_open: true + tty: true diff --git a/docs/docker-hub.md b/docs/docker-hub.md new file mode 100644 index 00000000..1a617be2 --- /dev/null +++ b/docs/docker-hub.md @@ -0,0 +1,95 @@ +# LinkedIn MCP Server + +A Model Context Protocol (MCP) server that connects AI assistants to LinkedIn. Access profiles, companies, and job postings through a Docker container. + +## Features + +- **Profile Access**: Get detailed LinkedIn profile information +- **Company Profiles**: Extract comprehensive company data +- **Job Details**: Retrieve job posting information +- **Job Search**: Search for jobs with keywords and location filters +- **People Search**: Search for people by keywords and location +- **Person Posts**: Get recent activity/posts from a person's profile +- **Company Posts**: Get recent posts from a company's LinkedIn feed +- **Compact References**: Return typed per-section links alongside readable text without shipping full-page markdown + +## Quick Start + +Create a browser profile locally, then mount it into Docker. + +**Step 1: Create profile on the host (one-time setup)** + +```bash +uvx linkedin-scraper-mcp --login +``` + +This opens a browser window where you log in manually (5 minute timeout for 2FA, captcha, etc.). The browser profile and cookies are saved under `~/.linkedin-mcp/`. On startup, Docker derives a Linux browser profile from your host cookies and creates a fresh session each time. For better stability, consider the [uvx setup](https://github.com/stickerdaniel/linkedin-mcp-server#-uvx-setup-recommended---universal). + +**Step 2: Configure Claude Desktop with Docker** + +```json +{ + "mcpServers": { + "linkedin": { + "command": "docker", + "args": [ + "run", "--rm", "-i", + "-v", "~/.linkedin-mcp:/home/pwuser/.linkedin-mcp", + "stickerdaniel/linkedin-mcp-server:latest" + ] + } + } +} +``` + +> **Note:** Docker containers don't have a display server, so you can't use the `--login` command in Docker. Create a source profile on your host first. +> +> **Note:** `stdio` is the default transport. Add `--transport streamable-http` only when you specifically want HTTP mode. +> +> **Note:** Tool calls are serialized within one server process to protect the +> shared LinkedIn browser session. Concurrent client requests queue instead of +> running in parallel. Use `LOG_LEVEL=DEBUG` to see scraper lock logs. + +## Environment Variables + +| Variable | Default | Description | +|----------|---------|-------------| +| `USER_DATA_DIR` | `~/.linkedin-mcp/profile` | Path to persistent browser profile directory | +| `LOG_LEVEL` | `WARNING` | Logging level: DEBUG, INFO, WARNING, ERROR | +| `TIMEOUT` | `5000` | Browser timeout in milliseconds | +| `USER_AGENT` | - | Custom browser user agent | +| `TRANSPORT` | `stdio` | Transport mode: stdio, streamable-http | +| `HOST` | `127.0.0.1` | HTTP server host (for streamable-http transport) | +| `PORT` | `8000` | HTTP server port (for streamable-http transport) | +| `HTTP_PATH` | `/mcp` | HTTP server path (for streamable-http transport) | +| `SLOW_MO` | `0` | Delay between browser actions in ms (debugging) | +| `VIEWPORT` | `1280x720` | Browser viewport size as WIDTHxHEIGHT | +| `CHROME_PATH` | - | Path to Chrome/Chromium executable (rarely needed in Docker) | +| `AUTH` | - | Set to `oauth` to enable OAuth 2.1 authentication for remote deployments | +| `OAUTH_BASE_URL` | - | Public URL of the server (required when `AUTH=oauth`) | +| `OAUTH_PASSWORD` | - | Password for the OAuth login page (required when `AUTH=oauth`) | +| `LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION` | `false` | Experimental: reuse checkpointed derived Linux runtime profiles across Docker restarts instead of fresh-bridging each startup | +| `LINKEDIN_TRACE_MODE` | `on_error` | Trace/log retention mode: `on_error` keeps ephemeral artifacts only when a failure occurs, `always` keeps every run, `off` disables trace persistence | + +**Example with custom timeout:** + +```json +{ + "mcpServers": { + "linkedin": { + "command": "docker", + "args": [ + "run", "-i", "--rm", + "-v", "~/.linkedin-mcp:/home/pwuser/.linkedin-mcp", + "-e", "TIMEOUT=10000", + "stickerdaniel/linkedin-mcp-server" + ] + } + } +} +``` + +## Repository + +- **Source**: +- **License**: Apache 2.0 diff --git a/linkedin_mcp_server/__init__.py b/linkedin_mcp_server/__init__.py new file mode 100644 index 00000000..99217578 --- /dev/null +++ b/linkedin_mcp_server/__init__.py @@ -0,0 +1,30 @@ +# src/linkedin_mcp_server/__init__.py +""" +LinkedIn MCP Server package. + +A Model Context Protocol (MCP) server that provides LinkedIn integration capabilities +for AI assistants. This package enables secure LinkedIn profile, company, and job +data scraping through a standardized MCP interface. + +Key Features: +- Secure LinkedIn authentication via session files +- LinkedIn profile, company, and job data scraping +- MCP-compliant server implementation using FastMCP +- Playwright browser automation with session persistence +- Layered configuration system with secure credential storage +- Docker containerization for easy deployment +- Claude Desktop DXT extension support + +Architecture: +- Clean separation between authentication, driver management, and MCP server +- Singleton pattern for browser session management +- Comprehensive error handling and logging +- Cross-platform compatibility (macOS, Windows, Linux) +""" + +from importlib.metadata import PackageNotFoundError, version + +try: + __version__ = version("linkedin-scraper-mcp") +except PackageNotFoundError: + __version__ = "0.0.0.dev" # Running from source without install diff --git a/linkedin_mcp_server/__main__.py b/linkedin_mcp_server/__main__.py new file mode 100644 index 00000000..80dc0679 --- /dev/null +++ b/linkedin_mcp_server/__main__.py @@ -0,0 +1,7 @@ +#!/usr/bin/env python3 +"""Entry point for linkedin-mcp-server command.""" + +from linkedin_mcp_server.cli_main import main + +if __name__ == "__main__": + main() diff --git a/linkedin_mcp_server/auth.py b/linkedin_mcp_server/auth.py new file mode 100644 index 00000000..5f91e7df --- /dev/null +++ b/linkedin_mcp_server/auth.py @@ -0,0 +1,268 @@ +""" +OAuth 2.1 provider with password-based login for remote MCP deployments. + +Subclasses FastMCP's InMemoryOAuthProvider to add a login page in the +authorization flow. All other OAuth infrastructure (DCR, PKCE, token +management, .well-known endpoints) is handled by the parent class. +""" + +import html +import secrets +import time + +from mcp.server.auth.provider import AuthorizationParams +from mcp.shared.auth import OAuthClientInformationFull +from starlette.requests import Request +from starlette.responses import RedirectResponse, Response +from starlette.routing import Route + +from fastmcp.server.auth.providers.in_memory import ( + AuthorizationCode, + InMemoryOAuthProvider, + construct_redirect_uri, +) + +# Pending auth requests expire after 10 minutes +_PENDING_REQUEST_TTL_SECONDS = 600 + +# Global rate limiting: max failed attempts across all request_ids in a time window +_GLOBAL_MAX_FAILED_ATTEMPTS = 20 +_GLOBAL_RATE_LIMIT_WINDOW_SECONDS = 300 # 5 minutes +_GLOBAL_LOCKOUT_SECONDS = 60 + +_LOGIN_SECURITY_HEADERS = { + "X-Frame-Options": "DENY", + "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'", + "X-Content-Type-Options": "nosniff", +} + + +def _html_response(content: str, status_code: int = 200) -> Response: + """HTMLResponse with security headers to prevent clickjacking and XSS.""" + from starlette.responses import HTMLResponse + + return HTMLResponse( + content, status_code=status_code, headers=_LOGIN_SECURITY_HEADERS + ) + + +# Max failed password attempts before the request is invalidated +_MAX_FAILED_ATTEMPTS = 5 + + +class PasswordOAuthProvider(InMemoryOAuthProvider): + """OAuth provider that requires a password before issuing authorization codes. + + When a client (e.g. claude.ai) hits /authorize, the user is redirected to + a login page. After entering the correct password, the authorization code + is issued and the user is redirected back to the client's callback URL. + """ + + def __init__( + self, + *, + base_url: str, + password: str, + **kwargs, + ): + from mcp.server.auth.settings import ClientRegistrationOptions + + super().__init__( + base_url=base_url, + client_registration_options=ClientRegistrationOptions(enabled=True), + **kwargs, + ) + self._password = password + self._pending_auth_requests: dict[str, dict] = {} + self._global_failed_attempts: list[float] = [] # timestamps of failures + self._global_lockout_until: float = 0.0 + + async def authorize( + self, client: OAuthClientInformationFull, params: AuthorizationParams + ) -> str: + """Redirect to login page instead of auto-approving.""" + self._cleanup_expired_requests() + + request_id = secrets.token_urlsafe(32) + self._pending_auth_requests[request_id] = { + "client_id": client.client_id, + "params": params, + "created_at": time.time(), + } + + base = str(self.base_url).rstrip("/") + return f"{base}/login?request_id={request_id}" + + def get_login_routes(self) -> list[Route]: + """Return Starlette routes for the login page.""" + return [ + Route("/login", endpoint=self._handle_login, methods=["GET", "POST"]), + ] + + def get_routes(self, mcp_path: str | None = None) -> list[Route]: + """Extend parent routes with login page.""" + routes = super().get_routes(mcp_path) + routes.extend(self.get_login_routes()) + return routes + + async def _handle_login(self, request: Request) -> Response: + if request.method == "GET": + return await self._render_login(request) + return await self._process_login(request) + + async def _render_login(self, request: Request) -> Response: + request_id = request.query_params.get("request_id", "") + pending = self._pending_auth_requests.get(request_id) if request_id else None + if not pending: + return _html_response("Invalid or expired login request.", status_code=400) + + if time.time() - pending["created_at"] > _PENDING_REQUEST_TTL_SECONDS: + del self._pending_auth_requests[request_id] + return _html_response( + "Login request expired. Please restart the authorization flow.", + status_code=400, + ) + + return _html_response(self._login_html(request_id)) + + async def _process_login(self, request: Request) -> Response: + form = await request.form() + request_id = str(form.get("request_id", "")) + password = str(form.get("password", "")) + + pending = self._pending_auth_requests.get(request_id) + if not pending: + return _html_response("Invalid or expired login request.", status_code=400) + + # Enforce TTL at submission time (not only during cleanup) + if time.time() - pending["created_at"] > _PENDING_REQUEST_TTL_SECONDS: + del self._pending_auth_requests[request_id] + return _html_response( + "Login request expired. Please restart the authorization flow.", + status_code=400, + ) + + # Global rate limit: reject if locked out + now = time.time() + if now < self._global_lockout_until: + return _html_response( + "Too many failed login attempts. Please try again later.", + status_code=429, + ) + + if not secrets.compare_digest(password, self._password): + # Track per-request failures + pending["failed_attempts"] = pending.get("failed_attempts", 0) + 1 + if pending["failed_attempts"] >= _MAX_FAILED_ATTEMPTS: + del self._pending_auth_requests[request_id] + + # Track global failures and trigger lockout if threshold exceeded + self._global_failed_attempts = [ + t + for t in self._global_failed_attempts + if now - t < _GLOBAL_RATE_LIMIT_WINDOW_SECONDS + ] + self._global_failed_attempts.append(now) + if len(self._global_failed_attempts) >= _GLOBAL_MAX_FAILED_ATTEMPTS: + self._global_lockout_until = now + _GLOBAL_LOCKOUT_SECONDS + return _html_response( + "Too many failed login attempts. Please try again later, " + "then restart the authorization flow from your client.", + status_code=429, + ) + + if pending.get("failed_attempts", 0) >= _MAX_FAILED_ATTEMPTS: + return _html_response( + "Too many failed attempts. Please restart the authorization flow.", + status_code=403, + ) + remaining = _MAX_FAILED_ATTEMPTS - pending["failed_attempts"] + return _html_response( + self._login_html( + request_id, + error=f"Invalid password. {remaining} attempt(s) remaining.", + ), + status_code=200, + ) + + # Password correct — create the authorization code and redirect + del self._pending_auth_requests[request_id] + + client = await self.get_client(pending["client_id"]) + if not client: + return _html_response( + "Client registration not found. " + "Please restart the authorization flow from your client.", + status_code=400, + ) + + params: AuthorizationParams = pending["params"] + scopes_list = params.scopes if params.scopes is not None else [] + + auth_code_value = f"auth_code_{secrets.token_hex(16)}" + expires_at = time.time() + 300 # 5 min + + auth_code = AuthorizationCode( + code=auth_code_value, + client_id=pending["client_id"], + redirect_uri=params.redirect_uri, + redirect_uri_provided_explicitly=params.redirect_uri_provided_explicitly, + scopes=scopes_list, + expires_at=expires_at, + code_challenge=params.code_challenge, + ) + self.auth_codes[auth_code_value] = auth_code + + redirect_url = construct_redirect_uri( + str(params.redirect_uri), code=auth_code_value, state=params.state + ) + return RedirectResponse(redirect_url, status_code=302) + + def _cleanup_expired_requests(self) -> None: + now = time.time() + expired = [ + rid + for rid, data in self._pending_auth_requests.items() + if now - data["created_at"] > _PENDING_REQUEST_TTL_SECONDS + ] + for rid in expired: + del self._pending_auth_requests[rid] + + @staticmethod + def _login_html(request_id: str, error: str = "") -> str: + error_html = ( + f'

{html.escape(error)}

' if error else "" + ) + return f""" + + + + +LinkedIn MCP Server — Login + + + +
+

LinkedIn MCP Server

+

Enter the server password to authorize this connection.

+ {error_html} +
+ + + + +
+
+ +""" diff --git a/linkedin_mcp_server/authentication.py b/linkedin_mcp_server/authentication.py new file mode 100644 index 00000000..bdd8c30d --- /dev/null +++ b/linkedin_mcp_server/authentication.py @@ -0,0 +1,86 @@ +""" +Authentication logic for LinkedIn MCP Server. + +Handles LinkedIn session management with persistent browser profile. +""" + +import logging +import shutil +from pathlib import Path + +from linkedin_mcp_server.session_state import ( + clear_auth_state as clear_all_auth_state, + get_source_profile_dir, + portable_cookie_path, + profile_exists, + source_state_path, + load_source_state, +) +from linkedin_mcp_server.exceptions import CredentialsNotFoundError + +logger = logging.getLogger(__name__) + + +def get_authentication_source() -> bool: + """ + Check if authentication is available via persistent profile. + + Returns: + True if profile exists + + Raises: + CredentialsNotFoundError: If no authentication method available + """ + profile_dir = get_source_profile_dir() + cookies_path = portable_cookie_path(profile_dir) + source_state = load_source_state(profile_dir) + if profile_exists(profile_dir) and cookies_path.exists() and source_state: + logger.info("Using source profile from %s", profile_dir) + return True + + if profile_exists(profile_dir) or cookies_path.exists(): + raise CredentialsNotFoundError( + "LinkedIn source session metadata is missing or incomplete.\n\n" + f"Expected source metadata: {source_state_path(profile_dir)}\n" + f"Expected portable cookies: {cookies_path}\n\n" + "Run with --login to create a fresh source session generation." + ) + + raise CredentialsNotFoundError( + "No LinkedIn source session found.\n\n" + "Options:\n" + " 1. Run with --login to create a source browser profile (recommended)\n" + " 2. Run with --no-headless to login interactively\n\n" + "For Docker users:\n" + " Create profile on host first: uv run -m linkedin_mcp_server --login\n" + " Then mount into Docker: -v ~/.linkedin-mcp:/home/pwuser/.linkedin-mcp" + ) + + +def clear_profile(profile_dir: Path | None = None) -> bool: + """ + Clear stored browser profile directory. + + Args: + profile_dir: Path to profile directory + + Returns: + True if clearing was successful + """ + if profile_dir is None: + profile_dir = get_source_profile_dir() + + if profile_dir.exists(): + try: + shutil.rmtree(profile_dir) + logger.info(f"Profile cleared from {profile_dir}") + return True + except OSError as e: + logger.warning(f"Could not clear profile: {e}") + return False + return True + + +def clear_auth_state(profile_dir: Path | None = None) -> bool: + """Clear source session artifacts and all derived runtime sessions.""" + return clear_all_auth_state(profile_dir or get_source_profile_dir()) diff --git a/linkedin_mcp_server/callbacks.py b/linkedin_mcp_server/callbacks.py new file mode 100644 index 00000000..be087a85 --- /dev/null +++ b/linkedin_mcp_server/callbacks.py @@ -0,0 +1,51 @@ +""" +Progress callbacks for MCP tools. + +Provides callback implementations that report progress for LinkedIn scraping +operations to MCP clients via FastMCP Context. +""" + +from typing import Any + +from fastmcp import Context + + +class ProgressCallback: + """Base callback class for progress tracking.""" + + async def on_start(self, scraper_type: str, url: str) -> None: + pass + + async def on_progress(self, message: str, percent: int) -> None: + pass + + async def on_complete(self, scraper_type: str, result: Any) -> None: + pass + + async def on_error(self, error: Exception) -> None: + pass + + +class MCPContextProgressCallback(ProgressCallback): + """Callback that reports progress to MCP clients via FastMCP Context.""" + + def __init__(self, ctx: Context): + self.ctx = ctx + + async def on_start(self, scraper_type: str, url: str) -> None: + """Report start to MCP client.""" + await self.ctx.report_progress( + progress=0, total=100, message=f"Starting {scraper_type}" + ) + + async def on_progress(self, message: str, percent: int) -> None: + """Report progress to MCP client.""" + await self.ctx.report_progress(progress=percent, total=100, message=message) + + async def on_complete(self, scraper_type: str, result: Any) -> None: + """Report completion to MCP client.""" + await self.ctx.report_progress(progress=100, total=100, message="Complete") + + async def on_error(self, error: Exception) -> None: + """Report error to MCP client.""" + await self.ctx.report_progress(progress=0, total=100, message=f"Error: {error}") diff --git a/linkedin_mcp_server/cli_main.py b/linkedin_mcp_server/cli_main.py new file mode 100644 index 00000000..ca3e9a02 --- /dev/null +++ b/linkedin_mcp_server/cli_main.py @@ -0,0 +1,426 @@ +""" +LinkedIn MCP Server - Main CLI application entry point. + +Implements a simplified two-phase startup: +1. Authentication Check - Verify browser profile is available +2. Server Runtime - MCP server startup with transport selection +""" + +import asyncio +import logging +import sys +from typing import Literal + +import inquirer + +from linkedin_mcp_server.core import AuthenticationError, RateLimitError + +from linkedin_mcp_server.authentication import ( + clear_auth_state, + get_authentication_source, +) +from linkedin_mcp_server.config import get_config +from linkedin_mcp_server.drivers.browser import ( + experimental_persist_derived_runtime, + close_browser, + get_or_create_browser, + get_profile_dir, + profile_exists, + set_headless, +) +from linkedin_mcp_server.debug_trace import should_keep_traces +from linkedin_mcp_server.exceptions import CredentialsNotFoundError +from linkedin_mcp_server.logging_config import configure_logging, teardown_trace_logging +from linkedin_mcp_server.session_state import ( + get_runtime_id, + load_runtime_state, + load_source_state, + portable_cookie_path, + runtime_profile_dir, + runtime_storage_state_path, + source_state_path, +) +from linkedin_mcp_server.server import create_mcp_server +from linkedin_mcp_server.setup import run_interactive_setup, run_profile_creation + +logger = logging.getLogger(__name__) + + +def choose_transport_interactive() -> Literal["stdio", "streamable-http"]: + """Prompt user for transport mode using inquirer.""" + questions = [ + inquirer.List( + "transport", + message="Choose mcp transport mode", + choices=[ + ("stdio (Default CLI mode)", "stdio"), + ("streamable-http (HTTP server mode)", "streamable-http"), + ], + default="stdio", + ) + ] + answers = inquirer.prompt(questions) + + if not answers: + raise KeyboardInterrupt("Transport selection cancelled by user") + + return answers["transport"] + + +def clear_profile_and_exit() -> None: + """Clear LinkedIn browser profile and exit.""" + config = get_config() + + configure_logging( + log_level=config.server.log_level, + json_format=not config.is_interactive and config.server.log_level != "DEBUG", + ) + + version = get_version() + logger.info(f"LinkedIn MCP Server v{version} - Profile Clear mode") + + auth_root = get_profile_dir().parent + + if not ( + profile_exists(get_profile_dir()) + or portable_cookie_path(get_profile_dir()).exists() + or source_state_path(get_profile_dir()).exists() + ): + print("ℹī¸ No authentication state found") + print("Nothing to clear.") + sys.exit(0) + + print(f"🔑 Clear LinkedIn authentication state from {auth_root}?") + + try: + confirmation = ( + input("Are you sure you want to clear the profile? (y/N): ").strip().lower() + ) + if confirmation not in ("y", "yes"): + print("❌ Operation cancelled") + sys.exit(0) + except KeyboardInterrupt: + print("\n❌ Operation cancelled") + sys.exit(0) + + if clear_auth_state(get_profile_dir()): + print("✅ LinkedIn authentication state cleared successfully!") + else: + print("❌ Failed to clear authentication state") + sys.exit(1) + + sys.exit(0) + + +def get_profile_and_exit() -> None: + """Create profile interactively and exit.""" + config = get_config() + + configure_logging( + log_level=config.server.log_level, + json_format=not config.is_interactive and config.server.log_level != "DEBUG", + ) + + version = get_version() + logger.info(f"LinkedIn MCP Server v{version} - Session Creation mode") + + user_data_dir = config.browser.user_data_dir + success = run_profile_creation(user_data_dir) + + sys.exit(0 if success else 1) + + +def profile_info_and_exit() -> None: + """Check profile validity and display info, then exit.""" + config = get_config() + + configure_logging( + log_level=config.server.log_level, + json_format=not config.is_interactive and config.server.log_level != "DEBUG", + ) + + version = get_version() + logger.info(f"LinkedIn MCP Server v{version} - Session Info mode") + + profile_dir = get_profile_dir() + cookies_path = portable_cookie_path(profile_dir) + source_state = load_source_state(profile_dir) + current_runtime = get_runtime_id() + + if not source_state or not profile_exists(profile_dir) or not cookies_path.exists(): + print(f"❌ No valid source session found at {profile_dir}") + print(" Run with --login to create a source session") + sys.exit(1) + + print(f"Current runtime: {current_runtime}") + print(f"Source runtime: {source_state.source_runtime_id}") + print(f"Login generation: {source_state.login_generation}") + + runtime_state = None + runtime_profile = None + runtime_storage_state = None + bridge_required = False + + if current_runtime == source_state.source_runtime_id: + print(f"Profile mode: source ({profile_dir})") + else: + runtime_state = load_runtime_state(current_runtime, profile_dir) + runtime_profile = runtime_profile_dir(current_runtime, profile_dir) + runtime_storage_state = runtime_storage_state_path(current_runtime, profile_dir) + if not experimental_persist_derived_runtime(): + bridge_required = True + print("Profile mode: foreign runtime (fresh bridge each startup)") + if runtime_profile.exists(): + print( + f"Derived runtime cache present but ignored by default: {runtime_profile}" + ) + else: + if ( + runtime_state + and runtime_state.source_login_generation + == source_state.login_generation + and profile_exists(runtime_profile) + and runtime_storage_state.exists() + ): + print( + f"Profile mode: derived (committed, current generation) ({runtime_profile})" + ) + else: + bridge_required = True + state = "stale generation" if runtime_state else "missing" + print(f"Profile mode: derived ({state})") + print( + "Storage snapshot: " + f"{runtime_storage_state if runtime_storage_state and runtime_storage_state.exists() else 'missing'}" + ) + + async def check_session() -> bool: + try: + set_headless(True) # Always check headless + browser = await get_or_create_browser() + return browser.is_authenticated + except AuthenticationError: + return False + except Exception as e: + logger.exception(f"Unexpected error checking session: {e}") + raise + finally: + await close_browser() + + if bridge_required: + if experimental_persist_derived_runtime(): + print( + "ℹī¸ A derived runtime profile will be created and checkpoint-committed on the next server startup." + ) + else: + print( + "ℹī¸ A fresh bridged foreign-runtime session will be created on the next server startup." + ) + print( + "ℹī¸ Source cookie validity is not verified in this mode. Run the server to test the bridge end-to-end." + ) + sys.exit(0) + + try: + valid = asyncio.run(check_session()) + except Exception as e: + print(f"❌ Could not validate session: {e}") + print(" Check logs and browser configuration.") + sys.exit(1) + + active_profile = profile_dir if runtime_profile is None else runtime_profile + if valid: + print(f"✅ Session is valid (profile: {active_profile})") + sys.exit(0) + + print(f"❌ Session expired or invalid (profile: {active_profile})") + print(" Run with --login to re-authenticate") + sys.exit(1) + + +def ensure_authentication_ready() -> None: + """ + Phase 1: Ensure authentication is ready. + + Checks for existing browser profile. + If not found, runs interactive setup in interactive mode. + + Raises: + CredentialsNotFoundError: If authentication setup fails + """ + config = get_config() + + # Check for existing profile + try: + get_authentication_source() + return + + except CredentialsNotFoundError: + pass + + # No authentication found - try interactive setup if possible + if not config.is_interactive: + raise CredentialsNotFoundError( + "No LinkedIn profile found.\n" + "Options:\n" + " 1. Run with --login to create a profile\n" + " 2. Run with --no-headless to login interactively" + ) + + # Run interactive setup + logger.info("No authentication found, starting interactive setup...") + success = run_interactive_setup() + + if not success: + raise CredentialsNotFoundError("Interactive setup was cancelled or failed") + + +def get_version() -> str: + """Get version from installed metadata with a source fallback.""" + try: + from importlib.metadata import PackageNotFoundError, version + + for package_name in ("linkedin-scraper-mcp", "linkedin-mcp-server"): + try: + return version(package_name) + except PackageNotFoundError: + continue + except Exception: + pass + + try: + import os + import tomllib + + pyproject_path = os.path.join( + os.path.dirname(os.path.dirname(__file__)), "pyproject.toml" + ) + with open(pyproject_path, "rb") as f: + data = tomllib.load(f) + return data["project"]["version"] + except Exception: + return "unknown" + + +def main() -> None: + """Main application entry point.""" + config = get_config() + + # Configure logging + configure_logging( + log_level=config.server.log_level, + json_format=not config.is_interactive and config.server.log_level != "DEBUG", + ) + + version = get_version() + + # Print banner in interactive mode + if config.is_interactive: + print(f"🔗 LinkedIn MCP Server v{version} 🔗") + print("=" * 40) + + logger.info(f"LinkedIn MCP Server v{version}") + + try: + # Set headless mode from config + set_headless(config.browser.headless) + + # Handle --logout flag + if config.server.logout: + clear_profile_and_exit() + + # Handle --login flag + if config.server.login: + get_profile_and_exit() + + # Handle --status flag + if config.server.status: + profile_info_and_exit() + + logger.debug(f"Server configuration: {config}") + + # Phase 1: Ensure Authentication is Ready + try: + ensure_authentication_ready() + if config.is_interactive: + print("✅ Authentication ready") + logger.info("Authentication ready") + + except CredentialsNotFoundError as e: + logger.error(f"Authentication setup failed: {e}") + if config.is_interactive: + print("\n❌ Authentication required") + print(str(e)) + sys.exit(1) + + except KeyboardInterrupt: + if config.is_interactive: + print("\n\n👋 Setup cancelled by user") + sys.exit(0) + + except (AuthenticationError, RateLimitError) as e: + logger.error(f"LinkedIn error during setup: {e}") + if config.is_interactive: + print(f"\n❌ {str(e)}") + sys.exit(1) + + except Exception as e: + logger.exception(f"Unexpected error during authentication setup: {e}") + if config.is_interactive: + print(f"\n❌ Setup failed: {e}") + sys.exit(1) + + # Phase 2: Server Runtime + try: + transport = config.server.transport + + # Prompt for transport in interactive mode if not explicitly set + if config.is_interactive and not config.server.transport_explicitly_set: + print("\n🚀 Server ready! Choose transport mode:") + transport = choose_transport_interactive() + + # Create and run the MCP server + mcp = create_mcp_server(oauth_config=config.server.oauth) + + if transport == "streamable-http": + mcp.run( + transport=transport, + host=config.server.host, + port=config.server.port, + path=config.server.path, + ) + else: + mcp.run(transport=transport) + + except KeyboardInterrupt: + exit_gracefully(0) + + except Exception as e: + logger.exception(f"Server runtime error: {e}") + if config.is_interactive: + print(f"\n❌ Server error: {e}") + exit_gracefully(1) + finally: + teardown_trace_logging(keep_traces=should_keep_traces()) + + +def exit_gracefully(exit_code: int = 0) -> None: + """Exit the application gracefully with browser cleanup.""" + try: + asyncio.run(close_browser()) + except Exception: + pass # Best effort cleanup + sys.exit(exit_code) + + +if __name__ == "__main__": + try: + main() + except KeyboardInterrupt: + exit_gracefully(0) + except Exception as e: + logger.exception( + f"Error running MCP server: {e}", + extra={"exception_type": type(e).__name__, "exception_message": str(e)}, + ) + exit_gracefully(1) diff --git a/linkedin_mcp_server/common_utils.py b/linkedin_mcp_server/common_utils.py new file mode 100644 index 00000000..91c486fb --- /dev/null +++ b/linkedin_mcp_server/common_utils.py @@ -0,0 +1,16 @@ +"""Small shared helpers used across diagnostics and session-state modules.""" + +from __future__ import annotations + +from datetime import UTC, datetime +import re + + +def slugify_fragment(value: str) -> str: + """Return a lowercase URL/file-safe fragment.""" + return re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-") + + +def utcnow_iso() -> str: + """Return the current UTC timestamp in a compact ISO-8601 form.""" + return datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z") diff --git a/linkedin_mcp_server/config/__init__.py b/linkedin_mcp_server/config/__init__.py new file mode 100644 index 00000000..d82b3b77 --- /dev/null +++ b/linkedin_mcp_server/config/__init__.py @@ -0,0 +1,42 @@ +""" +Configuration system for LinkedIn MCP Server. + +Provides a singleton pattern for configuration management with +loading from CLI arguments and environment variables. +""" + +import logging + +from .loaders import load_config +from .schema import AppConfig, BrowserConfig, OAuthConfig, ServerConfig + +logger = logging.getLogger(__name__) + +# Singleton pattern for configuration +_config: AppConfig | None = None + + +def get_config() -> AppConfig: + """Get the application configuration, initializing it if needed.""" + global _config + if _config is None: + _config = load_config() + logger.debug("Configuration loaded") + return _config + + +def reset_config() -> None: + """Reset the configuration to force reloading.""" + global _config + _config = None + logger.debug("Configuration reset") + + +__all__ = [ + "AppConfig", + "BrowserConfig", + "OAuthConfig", + "ServerConfig", + "get_config", + "reset_config", +] diff --git a/linkedin_mcp_server/config/loaders.py b/linkedin_mcp_server/config/loaders.py new file mode 100644 index 00000000..ce7dfd90 --- /dev/null +++ b/linkedin_mcp_server/config/loaders.py @@ -0,0 +1,406 @@ +""" +Configuration loading and argument parsing for LinkedIn MCP Server. + +Loads settings from CLI arguments and environment variables. +""" + +import argparse +import logging +import os +import sys +from typing import Literal, cast + +from dotenv import load_dotenv + +from .schema import AppConfig, ConfigurationError + +# Load .env file if present +load_dotenv() + +logger = logging.getLogger(__name__) + +# Boolean value mappings for environment variable parsing +TRUTHY_VALUES = ("1", "true", "True", "yes", "Yes") +FALSY_VALUES = ("0", "false", "False", "no", "No") + + +def positive_int(value: str) -> int: + """Argparse type for positive integers.""" + ivalue = int(value) + if ivalue <= 0: + raise argparse.ArgumentTypeError(f"must be positive, got {value}") + return ivalue + + +class EnvironmentKeys: + """Environment variable names used by the application.""" + + HEADLESS = "HEADLESS" + LOG_LEVEL = "LOG_LEVEL" + TRANSPORT = "TRANSPORT" + TIMEOUT = "TIMEOUT" + USER_AGENT = "USER_AGENT" + HOST = "HOST" + PORT = "PORT" + HTTP_PATH = "HTTP_PATH" + SLOW_MO = "SLOW_MO" + VIEWPORT = "VIEWPORT" + CHROME_PATH = "CHROME_PATH" + USER_DATA_DIR = "USER_DATA_DIR" + AUTH = "AUTH" + OAUTH_BASE_URL = "OAUTH_BASE_URL" + OAUTH_PASSWORD = "OAUTH_PASSWORD" + + +def is_interactive_environment() -> bool: + """ + Detect if running in an interactive environment (TTY). + + Returns: + True if both stdin and stdout are TTY devices + """ + try: + return sys.stdin.isatty() and sys.stdout.isatty() + except (AttributeError, OSError): + return False + + +def load_from_env(config: AppConfig) -> AppConfig: + """Load configuration from environment variables.""" + + # Log level + if log_level_env := os.environ.get(EnvironmentKeys.LOG_LEVEL): + log_level_upper = log_level_env.upper() + if log_level_upper in ("DEBUG", "INFO", "WARNING", "ERROR"): + config.server.log_level = cast( + Literal["DEBUG", "INFO", "WARNING", "ERROR"], log_level_upper + ) + + # Headless mode + if os.environ.get(EnvironmentKeys.HEADLESS) in FALSY_VALUES: + config.browser.headless = False + elif os.environ.get(EnvironmentKeys.HEADLESS) in TRUTHY_VALUES: + config.browser.headless = True + + # Transport mode + if transport_env := os.environ.get(EnvironmentKeys.TRANSPORT): + config.server.transport_explicitly_set = True + if transport_env == "stdio": + config.server.transport = "stdio" + elif transport_env == "streamable-http": + config.server.transport = "streamable-http" + else: + raise ConfigurationError( + f"Invalid TRANSPORT: '{transport_env}'. Must be 'stdio' or 'streamable-http'." + ) + + # Persistent browser profile directory + if user_data_dir := os.environ.get(EnvironmentKeys.USER_DATA_DIR): + config.browser.user_data_dir = user_data_dir + + # Timeout for page operations (validated in BrowserConfig.validate()) + if timeout_env := os.environ.get(EnvironmentKeys.TIMEOUT): + try: + config.browser.default_timeout = int(timeout_env) + except ValueError: + raise ConfigurationError( + f"Invalid TIMEOUT: '{timeout_env}'. Must be an integer." + ) + + # Custom user agent + if user_agent_env := os.environ.get(EnvironmentKeys.USER_AGENT): + config.browser.user_agent = user_agent_env + + # HTTP server host + if host_env := os.environ.get(EnvironmentKeys.HOST): + config.server.host = host_env + + # HTTP server port (validated in AppConfig.validate()) + if port_env := os.environ.get(EnvironmentKeys.PORT): + try: + config.server.port = int(port_env) + except ValueError: + raise ConfigurationError(f"Invalid PORT: '{port_env}'. Must be an integer.") + + # HTTP server path + if path_env := os.environ.get(EnvironmentKeys.HTTP_PATH): + config.server.path = path_env + + # Slow motion delay for debugging (validated in BrowserConfig.validate()) + if slow_mo_env := os.environ.get(EnvironmentKeys.SLOW_MO): + try: + config.browser.slow_mo = int(slow_mo_env) + except ValueError: + raise ConfigurationError( + f"Invalid SLOW_MO: '{slow_mo_env}'. Must be an integer." + ) + + # Browser viewport (validated in BrowserConfig.validate()) + if viewport_env := os.environ.get(EnvironmentKeys.VIEWPORT): + try: + width, height = viewport_env.lower().split("x") + config.browser.viewport_width = int(width) + config.browser.viewport_height = int(height) + except ValueError: + raise ConfigurationError( + f"Invalid VIEWPORT: '{viewport_env}'. Must be in format WxH (e.g., 1280x720)." + ) + + # Custom Chrome/Chromium executable path + if chrome_path_env := os.environ.get(EnvironmentKeys.CHROME_PATH): + config.browser.chrome_path = chrome_path_env + + # OAuth authentication + if auth_env := os.environ.get(EnvironmentKeys.AUTH): + if auth_env == "oauth": + config.server.oauth.enabled = True + else: + raise ConfigurationError(f"Invalid AUTH: '{auth_env}'. Must be 'oauth'.") + + if oauth_base_url := os.environ.get(EnvironmentKeys.OAUTH_BASE_URL): + config.server.oauth.base_url = oauth_base_url + + if oauth_password := os.environ.get(EnvironmentKeys.OAUTH_PASSWORD): + config.server.oauth.password = oauth_password + + return config + + +def load_from_args(config: AppConfig) -> AppConfig: + """Load configuration from command line arguments.""" + parser = argparse.ArgumentParser( + description="LinkedIn MCP Server - A Model Context Protocol server for LinkedIn integration" + ) + + parser.add_argument( + "--no-headless", + action="store_true", + help="Run browser with a visible window (useful for login and debugging)", + ) + + parser.add_argument( + "--log-level", + choices=["DEBUG", "INFO", "WARNING", "ERROR"], + help="Set logging level (default: WARNING)", + ) + + parser.add_argument( + "--transport", + choices=["stdio", "streamable-http"], + default=None, + help="Specify the transport mode (stdio or streamable-http)", + ) + + parser.add_argument( + "--host", + type=str, + default=None, + help="HTTP server host (default: 127.0.0.1)", + ) + + parser.add_argument( + "--port", + type=int, + default=None, + help="HTTP server port (default: 8000)", + ) + + parser.add_argument( + "--path", + type=str, + default=None, + help="HTTP server path (default: /mcp)", + ) + + # Browser configuration + parser.add_argument( + "--slow-mo", + type=int, + default=0, + metavar="MS", + help="Slow down browser actions by N milliseconds (debugging)", + ) + + parser.add_argument( + "--user-agent", + type=str, + default=None, + help="Custom browser user agent", + ) + + parser.add_argument( + "--viewport", + type=str, + default=None, + metavar="WxH", + help="Browser viewport size (default: 1280x720)", + ) + + parser.add_argument( + "--timeout", + type=positive_int, + default=None, + metavar="MS", + help="Browser timeout for page operations in milliseconds (default: 5000)", + ) + + parser.add_argument( + "--chrome-path", + type=str, + default=None, + metavar="PATH", + help="Path to Chrome/Chromium executable (for custom browser installations)", + ) + + # Session management + parser.add_argument( + "--login", + action="store_true", + help="Login interactively via browser and save persistent profile", + ) + + parser.add_argument( + "--status", + action="store_true", + help="Check if current session is valid and exit", + ) + + parser.add_argument( + "--logout", + action="store_true", + help="Clear stored LinkedIn browser profile", + ) + + parser.add_argument( + "--user-data-dir", + type=str, + default=None, + metavar="PATH", + help="Path to persistent browser profile directory (default: ~/.linkedin-mcp/profile)", + ) + + # OAuth authentication + parser.add_argument( + "--auth", + choices=["oauth"], + default=None, + help="Enable authentication (oauth for OAuth 2.1)", + ) + + parser.add_argument( + "--oauth-base-url", + type=str, + default=None, + metavar="URL", + help="Public URL of this server for OAuth (e.g. https://my-mcp.example.com)", + ) + + parser.add_argument( + "--oauth-password", + type=str, + default=None, + metavar="PASSWORD", + help="Password for the OAuth login page (visible in process list; prefer OAUTH_PASSWORD env var)", + ) + + args = parser.parse_args() + + # Update configuration with parsed arguments + if args.no_headless: + config.browser.headless = False + + if args.log_level: + config.server.log_level = args.log_level + + if args.transport: + config.server.transport = args.transport + config.server.transport_explicitly_set = True + + if args.host: + config.server.host = args.host + + if args.port: + config.server.port = args.port + + if args.path: + config.server.path = args.path + + # Browser configuration + if args.slow_mo: + config.browser.slow_mo = args.slow_mo + + if args.user_agent: + config.browser.user_agent = args.user_agent + + # Viewport (validated in BrowserConfig.validate()) + if args.viewport: + try: + width, height = args.viewport.lower().split("x") + config.browser.viewport_width = int(width) + config.browser.viewport_height = int(height) + except ValueError: + raise ConfigurationError( + f"Invalid --viewport: '{args.viewport}'. Must be in format WxH (e.g., 1280x720)." + ) + + if args.timeout is not None: + config.browser.default_timeout = args.timeout + + if args.chrome_path: + config.browser.chrome_path = args.chrome_path + + # Session management + if args.login: + config.server.login = True + + if args.status: + config.server.status = True + + if args.logout: + config.server.logout = True + + if args.user_data_dir: + config.browser.user_data_dir = args.user_data_dir + + # OAuth authentication + if args.auth == "oauth": + config.server.oauth.enabled = True + + if args.oauth_base_url: + config.server.oauth.base_url = args.oauth_base_url + + if args.oauth_password: + config.server.oauth.password = args.oauth_password + + return config + + +def load_config() -> AppConfig: + """ + Load configuration with clear precedence order. + + Configuration is loaded in the following priority order: + 1. Command line arguments (highest priority) + 2. Environment variables + 3. Defaults (lowest priority) + + Returns: + Fully configured application settings + """ + # Start with default configuration + config = AppConfig() + + # Set interactive mode + config.is_interactive = is_interactive_environment() + logger.debug(f"Interactive mode: {config.is_interactive}") + + # Override with environment variables + config = load_from_env(config) + + # Override with command line arguments (highest priority) + config = load_from_args(config) + + # Validate final configuration + config.validate() + + return config diff --git a/linkedin_mcp_server/config/schema.py b/linkedin_mcp_server/config/schema.py new file mode 100644 index 00000000..82a4152a --- /dev/null +++ b/linkedin_mcp_server/config/schema.py @@ -0,0 +1,158 @@ +""" +Configuration schema definitions for LinkedIn MCP Server. + +Defines the dataclass schemas that represent the application's configuration +structure with type-safe configuration objects and default values. +""" + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Literal +from urllib.parse import urlparse + + +class ConfigurationError(Exception): + """Raised when configuration validation fails.""" + + +@dataclass +class BrowserConfig: + """Configuration for browser settings.""" + + headless: bool = True + slow_mo: int = 0 # Milliseconds between browser actions (debugging) + user_agent: str | None = None # Custom browser user agent + viewport_width: int = 1280 + viewport_height: int = 720 + default_timeout: int = 5000 # Milliseconds for page operations + chrome_path: str | None = None # Path to Chrome/Chromium executable + user_data_dir: str = "~/.linkedin-mcp/profile" # Persistent browser profile + + def validate(self) -> None: + """Validate browser configuration values.""" + if self.slow_mo < 0: + raise ConfigurationError( + f"slow_mo must be non-negative, got {self.slow_mo}" + ) + if self.default_timeout <= 0: + raise ConfigurationError( + f"default_timeout must be positive, got {self.default_timeout}" + ) + if self.viewport_width <= 0 or self.viewport_height <= 0: + raise ConfigurationError( + f"viewport dimensions must be positive, got {self.viewport_width}x{self.viewport_height}" + ) + if self.chrome_path: + chrome_path = Path(self.chrome_path) + if not chrome_path.exists(): + raise ConfigurationError( + f"chrome_path '{self.chrome_path}' does not exist" + ) + if not chrome_path.is_file(): + raise ConfigurationError( + f"chrome_path '{self.chrome_path}' is not a file" + ) + + +@dataclass +class OAuthConfig: + """OAuth 2.1 authentication configuration for remote deployments.""" + + enabled: bool = False + base_url: str | None = ( + None # Public URL of this server (e.g. https://my-mcp.example.com) + ) + password: str | None = None # Password for the OAuth login page + + +@dataclass +class ServerConfig: + """MCP server configuration.""" + + transport: Literal["stdio", "streamable-http"] = "stdio" + transport_explicitly_set: bool = False + log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "WARNING" + login: bool = False + status: bool = False # Check session validity and exit + logout: bool = False + # HTTP transport configuration + host: str = "127.0.0.1" + port: int = 8000 + path: str = "/mcp" + # OAuth authentication + oauth: OAuthConfig = field(default_factory=OAuthConfig) + + +@dataclass +class AppConfig: + """Main application configuration.""" + + browser: BrowserConfig = field(default_factory=BrowserConfig) + server: ServerConfig = field(default_factory=ServerConfig) + is_interactive: bool = field(default=False) + + def validate(self) -> None: + """Validate all configuration values. Call after modifying config.""" + self.browser.validate() + if self.server.transport == "streamable-http": + self._validate_transport_config() + self._validate_path_format() + self._validate_port_range() + self._validate_oauth() + + def _validate_transport_config(self) -> None: + """Validate transport configuration is consistent.""" + if not self.server.host: + raise ConfigurationError("HTTP transport requires a valid host") + if not self.server.port: + raise ConfigurationError("HTTP transport requires a valid port") + + def _validate_port_range(self) -> None: + """Validate port is in valid range.""" + if not (1 <= self.server.port <= 65535): + raise ConfigurationError( + f"Port {self.server.port} is not in valid range (1-65535)" + ) + + def _validate_path_format(self) -> None: + """Validate path format for HTTP transport.""" + if not self.server.path.startswith("/"): + raise ConfigurationError( + f"HTTP path '{self.server.path}' must start with '/'" + ) + if len(self.server.path) < 2: + raise ConfigurationError( + f"HTTP path '{self.server.path}' must be at least 2 characters" + ) + + def _validate_oauth(self) -> None: + """Validate OAuth configuration when enabled. + + Skipped for command-only modes (--login, --status, --logout) that exit + before starting the server, so AUTH=oauth in the environment doesn't + break maintenance commands. + """ + if not self.server.oauth.enabled: + return + if self.server.login or self.server.status or self.server.logout: + return + if self.server.transport != "streamable-http": + raise ConfigurationError("OAuth requires --transport streamable-http") + if not self.server.oauth.base_url: + raise ConfigurationError( + "OAuth requires OAUTH_BASE_URL (the public URL of this server)" + ) + if not self.server.oauth.base_url.startswith("https://"): + raise ConfigurationError( + "OAuth requires OAUTH_BASE_URL to use HTTPS (e.g. https://my-mcp.example.com)" + ) + parsed = urlparse(self.server.oauth.base_url) + if parsed.path not in ("", "/"): + raise ConfigurationError( + "OAuth base URL must not contain a path component " + "(e.g. https://my-mcp.example.com, not https://my-mcp.example.com/api)" + ) + if not self.server.oauth.password: + raise ConfigurationError( + "OAuth requires OAUTH_PASSWORD (password for the login page)" + ) diff --git a/linkedin_mcp_server/constants.py b/linkedin_mcp_server/constants.py new file mode 100644 index 00000000..5f366d45 --- /dev/null +++ b/linkedin_mcp_server/constants.py @@ -0,0 +1,3 @@ +"""Project-wide constants.""" + +TOOL_TIMEOUT_SECONDS: float = 90.0 diff --git a/linkedin_mcp_server/core/__init__.py b/linkedin_mcp_server/core/__init__.py new file mode 100644 index 00000000..aba9ff76 --- /dev/null +++ b/linkedin_mcp_server/core/__init__.py @@ -0,0 +1,41 @@ +"""Core browser management, authentication, and scraping utilities.""" + +from .auth import ( + detect_auth_barrier, + detect_auth_barrier_quick, + is_logged_in, + resolve_remember_me_prompt, + wait_for_manual_login, + warm_up_browser, +) +from .browser import BrowserManager +from .exceptions import ( + AuthenticationError, + ElementNotFoundError, + LinkedInScraperException, + NetworkError, + ProfileNotFoundError, + RateLimitError, + ScrapingError, +) +from .utils import detect_rate_limit, handle_modal_close, scroll_to_bottom + +__all__ = [ + "AuthenticationError", + "BrowserManager", + "detect_auth_barrier", + "detect_auth_barrier_quick", + "ElementNotFoundError", + "LinkedInScraperException", + "NetworkError", + "ProfileNotFoundError", + "RateLimitError", + "ScrapingError", + "detect_rate_limit", + "handle_modal_close", + "is_logged_in", + "resolve_remember_me_prompt", + "scroll_to_bottom", + "wait_for_manual_login", + "warm_up_browser", +] diff --git a/linkedin_mcp_server/core/auth.py b/linkedin_mcp_server/core/auth.py new file mode 100644 index 00000000..08eb2b9e --- /dev/null +++ b/linkedin_mcp_server/core/auth.py @@ -0,0 +1,298 @@ +"""Authentication functions for LinkedIn.""" + +import asyncio +import logging +import re +from urllib.parse import urlparse + +from patchright.async_api import Page, TimeoutError as PlaywrightTimeoutError + +from .exceptions import AuthenticationError + +logger = logging.getLogger(__name__) + +_AUTH_BLOCKER_URL_PATTERNS = ( + "/login", + "/authwall", + "/checkpoint", + "/challenge", + "/uas/login", + "/uas/consumer-email-challenge", +) +_LOGIN_TITLE_PATTERNS = ( + "linkedin login", + "sign in | linkedin", +) +_AUTH_BARRIER_TEXT_MARKERS = ( + ("welcome back", "sign in using another account"), + ("welcome back", "join now"), + ("choose an account", "sign in using another account"), + ("continue as", "sign in using another account"), +) +_REMEMBER_ME_CONTAINER_SELECTOR = "#rememberme-div" +_REMEMBER_ME_BUTTON_SELECTOR = "#rememberme-div button" + + +async def warm_up_browser(page: Page) -> None: + """Visit normal sites to appear more human-like before LinkedIn access.""" + sites = [ + "https://www.google.com", + "https://www.wikipedia.org", + "https://www.github.com", + ] + + logger.info("Warming up browser by visiting normal sites...") + + failures = 0 + for site in sites: + try: + await page.goto(site, wait_until="domcontentloaded", timeout=10000) + await asyncio.sleep(1) + logger.debug("Visited %s", site) + except Exception as e: + failures += 1 + logger.debug("Could not visit %s: %s", site, e) + continue + + if failures == len(sites): + logger.warning("Browser warm-up failed: none of %d sites reachable", len(sites)) + else: + logger.info("Browser warm-up complete") + + +async def is_logged_in(page: Page) -> bool: + """Check if currently logged in to LinkedIn. + + Uses a three-tier strategy: + 1. Fail-fast on auth blocker URLs + 2. Check for navigation elements (primary) + 3. URL-based fallback for authenticated-only pages + """ + try: + current_url = page.url + + # Step 1: Fail-fast on auth blockers + if _is_auth_blocker_url(current_url): + return False + + # Step 2: Selector check (PRIMARY) + old_selectors = '.global-nav__primary-link, [data-control-name="nav.settings"]' + old_count = await page.locator(old_selectors).count() + + new_selectors = 'nav a[href*="/feed"], nav button:has-text("Home"), nav a[href*="/mynetwork"]' + new_count = await page.locator(new_selectors).count() + + has_nav_elements = old_count > 0 or new_count > 0 + + # Step 3: URL fallback + authenticated_only_pages = [ + "/feed", + "/mynetwork", + "/messaging", + "/notifications", + ] + is_authenticated_page = any( + pattern in current_url for pattern in authenticated_only_pages + ) + + if not is_authenticated_page: + return has_nav_elements + + if has_nav_elements: + return True + + # Empty authenticated-only pages are a false positive during cookie + # bridge recovery. Require some real page content before trusting URL. + body_text = await page.evaluate("() => document.body?.innerText || ''") + if not isinstance(body_text, str): + return False + + return bool(body_text.strip()) + except PlaywrightTimeoutError: + logger.warning( + "Timeout checking login status on %s — treating as not logged in", + page.url, + ) + return False + except Exception: + logger.error("Unexpected error checking login status", exc_info=True) + raise + + +async def detect_auth_barrier(page: Page) -> str | None: + """Detect LinkedIn auth/account-picker barriers on the current page.""" + return await _detect_auth_barrier(page, include_body_text=True) + + +async def _detect_auth_barrier( + page: Page, + *, + include_body_text: bool, +) -> str | None: + """Detect LinkedIn auth/account-picker barriers on the current page.""" + try: + current_url = page.url + if _is_auth_blocker_url(current_url): + return f"auth blocker URL: {current_url}" + + try: + title = (await page.title()).strip().lower() + except Exception: + title = "" + if any(pattern in title for pattern in _LOGIN_TITLE_PATTERNS): + return f"login title: {title}" + + if not include_body_text: + return None + + try: + body_text = await page.evaluate("() => document.body?.innerText || ''") + except Exception: + body_text = "" + if not isinstance(body_text, str): + body_text = "" + + normalized = re.sub(r"\s+", " ", body_text).strip().lower() + for marker_group in _AUTH_BARRIER_TEXT_MARKERS: + if all(marker in normalized for marker in marker_group): + return f"auth barrier text: {' + '.join(marker_group)}" + + return None + except PlaywrightTimeoutError: + logger.warning( + "Timeout checking auth barrier on %s — continuing without barrier detection", + page.url, + ) + return None + except Exception: + logger.error("Unexpected error checking auth barrier", exc_info=True) + return None + + +async def detect_auth_barrier_quick(page: Page) -> str | None: + """Cheap auth-barrier check for normal navigations. + + Uses URL and title only, avoiding a full body-text fetch on healthy pages. + """ + return await _detect_auth_barrier(page, include_body_text=False) + + +async def resolve_remember_me_prompt(page: Page) -> bool: + """Click through LinkedIn's saved-account chooser when it appears.""" + try: + logger.debug("Checking remember-me prompt on %s", page.url) + try: + await page.wait_for_selector(_REMEMBER_ME_CONTAINER_SELECTOR, timeout=3000) + logger.debug("Remember-me container appeared") + except PlaywrightTimeoutError: + logger.debug("Remember-me container did not appear in time") + return False + + target_locator = page.locator(_REMEMBER_ME_BUTTON_SELECTOR) + target = target_locator.first + try: + target_count = await target_locator.count() + except Exception: + logger.debug( + "Could not count remember-me buttons; continuing with first match", + exc_info=True, + ) + target_count = -1 + logger.debug( + "Remember-me target count for %s: %d", + _REMEMBER_ME_BUTTON_SELECTOR, + target_count, + ) + if target_count == 0: + logger.debug( + "Remember-me container appeared without any matching button selector" + ) + return False + try: + await target.wait_for(state="visible", timeout=3000) + logger.debug("Remember-me button became visible") + except PlaywrightTimeoutError: + logger.debug( + "Remember-me prompt container appeared without a visible login button" + ) + return False + + logger.info("Clicking LinkedIn saved-account chooser to resume session") + try: + await target.scroll_into_view_if_needed(timeout=3000) + except PlaywrightTimeoutError: + logger.debug("Remember-me button did not scroll into view in time") + + try: + await target.click(timeout=5000) + logger.debug("Remember-me button click succeeded") + except PlaywrightTimeoutError: + logger.debug("Retrying remember-me prompt click with force=True") + await target.click(timeout=5000, force=True) + logger.debug("Remember-me button force-click succeeded") + try: + await page.wait_for_load_state("domcontentloaded", timeout=10000) + except PlaywrightTimeoutError: + logger.debug("Remember-me prompt click did not finish loading in time") + await asyncio.sleep(1) + return True + except PlaywrightTimeoutError: + logger.debug("Remember-me prompt was present but not clickable in time") + return False + except Exception: + logger.debug("Failed to resolve remember-me prompt", exc_info=True) + return False + + +def _is_auth_blocker_url(url: str) -> bool: + """Return True only for real auth routes, not arbitrary slug substrings.""" + path = urlparse(url).path or "/" + + if path in _AUTH_BLOCKER_URL_PATTERNS: + return True + + return any( + path == f"{pattern}/" or path.startswith(f"{pattern}/") + for pattern in _AUTH_BLOCKER_URL_PATTERNS + ) + + +async def wait_for_manual_login(page: Page, timeout: int = 300000) -> None: + """Wait for user to manually complete login. + + Args: + page: Patchright page object + timeout: Timeout in milliseconds (default: 5 minutes) + + Raises: + AuthenticationError: If timeout or login not completed + """ + logger.info( + "Please complete the login process manually in the browser. " + "Waiting up to 5 minutes..." + ) + + loop = asyncio.get_running_loop() + start_time = loop.time() + + while True: + if await resolve_remember_me_prompt(page): + logger.info("Resolved saved-account chooser during manual login flow") + elapsed = (loop.time() - start_time) * 1000 + if elapsed > timeout: + raise AuthenticationError( + "Manual login timeout. Please try again and complete login faster." + ) + continue + + if await is_logged_in(page): + logger.info("Manual login completed successfully") + return + + elapsed = (loop.time() - start_time) * 1000 + if elapsed > timeout: + raise AuthenticationError( + "Manual login timeout. Please try again and complete login faster." + ) + + await asyncio.sleep(1) diff --git a/linkedin_mcp_server/core/browser.py b/linkedin_mcp_server/core/browser.py new file mode 100644 index 00000000..19df362d --- /dev/null +++ b/linkedin_mcp_server/core/browser.py @@ -0,0 +1,330 @@ +"""Browser lifecycle management using Patchright with persistent context.""" + +import json +import logging +import os +from pathlib import Path +from typing import Any + +from patchright.async_api import ( + BrowserContext, + Page, + Playwright, + async_playwright, +) + +from .exceptions import NetworkError + +logger = logging.getLogger(__name__) + +_DEFAULT_USER_DATA_DIR = Path.home() / ".linkedin-mcp" / "profile" + + +class BrowserManager: + """Async context manager for Patchright browser with persistent profile. + + Session persistence is handled automatically by the persistent browser + context -- all cookies, localStorage, and session state are retained in + the ``user_data_dir`` between runs. + """ + + def __init__( + self, + user_data_dir: str | Path = _DEFAULT_USER_DATA_DIR, + headless: bool = True, + slow_mo: int = 0, + viewport: dict[str, int] | None = None, + user_agent: str | None = None, + **launch_options: Any, + ): + self.user_data_dir = str(Path(user_data_dir).expanduser()) + self.headless = headless + self.slow_mo = slow_mo + self.viewport = viewport or {"width": 1280, "height": 720} + self.user_agent = user_agent + self.launch_options = launch_options + + self._playwright: Playwright | None = None + self._context: BrowserContext | None = None + self._page: Page | None = None + self._is_authenticated = False + + async def __aenter__(self) -> "BrowserManager": + await self.start() + return self + + async def __aexit__( + self, exc_type: object, exc_val: object, exc_tb: object + ) -> None: + await self.close() + + async def start(self) -> None: + """Start Patchright and launch persistent browser context.""" + if self._context is not None: + raise RuntimeError("Browser already started. Call close() first.") + try: + self._playwright = await async_playwright().start() + + Path(self.user_data_dir).mkdir(parents=True, exist_ok=True) + + context_options: dict[str, Any] = { + "headless": self.headless, + "slow_mo": self.slow_mo, + "viewport": self.viewport, + **self.launch_options, + } + + if self.user_agent: + context_options["user_agent"] = self.user_agent + + self._context = await self._playwright.chromium.launch_persistent_context( + self.user_data_dir, + **context_options, + ) + + logger.info( + "Persistent browser launched (headless=%s, user_data_dir=%s)", + self.headless, + self.user_data_dir, + ) + + if self._context.pages: + self._page = self._context.pages[0] + else: + self._page = await self._context.new_page() + + logger.info("Browser context and page ready") + + except Exception as e: + await self.close() + raise NetworkError(f"Failed to start browser: {e}") from e + + async def close(self) -> None: + """Close persistent context and cleanup resources.""" + context = self._context + playwright = self._playwright + self._context = None + self._page = None + self._playwright = None + + if context is None and playwright is None: + return + + if context is not None: + try: + await context.close() + except Exception as exc: + logger.error("Error closing browser context: %s", exc) + + if playwright is not None: + try: + await playwright.stop() + except Exception as exc: + logger.error("Error stopping playwright: %s", exc) + + logger.info("Browser closed") + + @property + def page(self) -> Page: + if not self._page: + raise RuntimeError( + "Browser not started. Use async context manager or call start()." + ) + return self._page + + @property + def context(self) -> BrowserContext: + if not self._context: + raise RuntimeError("Browser context not initialized.") + return self._context + + async def set_cookie( + self, name: str, value: str, domain: str = ".linkedin.com" + ) -> None: + if not self._context: + raise RuntimeError("No browser context") + + await self._context.add_cookies( + [{"name": name, "value": value, "domain": domain, "path": "/"}] + ) + logger.debug("Cookie set: %s", name) + + @property + def is_authenticated(self) -> bool: + return self._is_authenticated + + @is_authenticated.setter + def is_authenticated(self, value: bool) -> None: + self._is_authenticated = value + + def _default_cookie_path(self) -> Path: + return Path(self.user_data_dir).parent / "cookies.json" + + @staticmethod + def _normalize_cookie_domain(cookie: Any) -> dict[str, Any]: + """Normalize cookie domain for cross-platform compatibility. + + Playwright reports some LinkedIn cookies with ``.www.linkedin.com`` + domain, but Chromium's internal store uses ``.linkedin.com``. + """ + domain = cookie.get("domain", "") + if domain in (".www.linkedin.com", "www.linkedin.com"): + cookie = {**cookie, "domain": ".linkedin.com"} + return cookie + + async def export_cookies(self, cookie_path: str | Path | None = None) -> bool: + """Export LinkedIn cookies to a portable JSON file.""" + if not self._context: + logger.warning("Cannot export cookies: no browser context") + return False + + path = Path(cookie_path) if cookie_path else self._default_cookie_path() + try: + all_cookies = await self._context.cookies() + cookies = [ + self._normalize_cookie_domain(c) + for c in all_cookies + if "linkedin.com" in c.get("domain", "") + ] + path.write_text(json.dumps(cookies, indent=2)) + logger.info("Exported %d LinkedIn cookies to %s", len(cookies), path) + return True + except Exception: + logger.exception("Failed to export cookies") + return False + + async def export_storage_state( + self, path: str | Path, *, indexed_db: bool = True + ) -> bool: + """Export the current browser storage state for diagnostics and recovery.""" + if not self._context: + logger.warning("Cannot export storage state: no browser context") + return False + + storage_path = Path(path) + storage_path.parent.mkdir(parents=True, exist_ok=True) + try: + await self._context.storage_state( + path=storage_path, + indexed_db=indexed_db, + ) + logger.info( + "Exported runtime storage snapshot to %s (indexed_db=%s)", + storage_path, + indexed_db, + ) + return True + except Exception: + logger.exception("Failed to export storage state to %s", storage_path) + return False + + _BRIDGE_COOKIE_PRESETS = { + "bridge_core": frozenset( + { + "li_at", + "li_rm", + "JSESSIONID", + "bcookie", + "bscookie", + "liap", + "lidc", + "li_gc", + "lang", + "timezone", + "li_mc", + } + ), + "auth_minimal": frozenset( + { + "li_at", + "JSESSIONID", + "bcookie", + "bscookie", + "lidc", + } + ), + } + + @classmethod + def _bridge_cookie_names( + cls, preset_name: str | None = None + ) -> tuple[str, frozenset[str]]: + preset_name = ( + preset_name + or os.getenv( + "LINKEDIN_DEBUG_BRIDGE_COOKIE_SET", + "auth_minimal", + ).strip() + or "auth_minimal" + ) + preset = cls._BRIDGE_COOKIE_PRESETS.get(preset_name) + if preset is None: + logger.warning( + "Unknown LINKEDIN_DEBUG_BRIDGE_COOKIE_SET=%r, falling back to auth_minimal", + preset_name, + ) + preset_name = "auth_minimal" + preset = cls._BRIDGE_COOKIE_PRESETS[preset_name] + return preset_name, preset + + async def import_cookies( + self, + cookie_path: str | Path | None = None, + *, + preset_name: str | None = None, + ) -> bool: + """Import the portable LinkedIn bridge cookie subset. + + Fresh browser-side cookies are preserved. The imported subset is the + smallest known set that can reconstruct a usable authenticated page in + a fresh profile. + """ + if not self._context: + logger.warning("Cannot import cookies: no browser context") + return False + + path = Path(cookie_path) if cookie_path else self._default_cookie_path() + if not path.exists(): + logger.debug("No portable cookie file at %s", path) + return False + + try: + all_cookies = json.loads(path.read_text()) + if not all_cookies: + logger.debug("Cookie file is empty") + return False + + resolved_preset_name, bridge_cookie_names = self._bridge_cookie_names( + preset_name + ) + + cookies = [ + self._normalize_cookie_domain(c) + for c in all_cookies + if "linkedin.com" in c.get("domain", "") + and c.get("name") in bridge_cookie_names + ] + + has_li_at = any(c.get("name") == "li_at" for c in cookies) + if not has_li_at: + logger.warning("No li_at cookie found in %s", path) + return False + + await self._context.add_cookies(cookies) # type: ignore[arg-type] + logger.info( + "Imported %d LinkedIn bridge cookies from %s (preset=%s, li_at=%s): %s", + len(cookies), + path, + resolved_preset_name, + has_li_at, + ", ".join(c["name"] for c in cookies), + ) + return True + except Exception: + logger.exception("Failed to import cookies from %s", path) + return False + + def cookie_file_exists(self, cookie_path: str | Path | None = None) -> bool: + """Check if a portable cookie file exists.""" + path = Path(cookie_path) if cookie_path else self._default_cookie_path() + return path.exists() diff --git a/linkedin_mcp_server/core/exceptions.py b/linkedin_mcp_server/core/exceptions.py new file mode 100644 index 00000000..0186c8df --- /dev/null +++ b/linkedin_mcp_server/core/exceptions.py @@ -0,0 +1,45 @@ +"""Custom exceptions for LinkedIn scraping operations.""" + + +class LinkedInScraperException(Exception): + """Base exception for LinkedIn scraper.""" + + pass + + +class AuthenticationError(LinkedInScraperException): + """Raised when authentication fails.""" + + pass + + +class RateLimitError(LinkedInScraperException): + """Raised when rate limiting is detected.""" + + def __init__(self, message: str, suggested_wait_time: int = 300): + super().__init__(message) + self.suggested_wait_time = suggested_wait_time + + +class ElementNotFoundError(LinkedInScraperException): + """Raised when an expected element is not found.""" + + pass + + +class ProfileNotFoundError(LinkedInScraperException): + """Raised when a profile/page returns 404.""" + + pass + + +class NetworkError(LinkedInScraperException): + """Raised when network-related issues occur.""" + + pass + + +class ScrapingError(LinkedInScraperException): + """Raised when scraping fails for various reasons.""" + + pass diff --git a/linkedin_mcp_server/core/utils.py b/linkedin_mcp_server/core/utils.py new file mode 100644 index 00000000..7f3a3ebe --- /dev/null +++ b/linkedin_mcp_server/core/utils.py @@ -0,0 +1,194 @@ +"""Utility functions for scraping operations.""" + +import asyncio +import logging + +from patchright.async_api import Page, TimeoutError as PlaywrightTimeoutError + +from .exceptions import RateLimitError + +logger = logging.getLogger(__name__) + + +async def detect_rate_limit(page: Page) -> None: + """Detect if LinkedIn has rate-limited or security-challenged the session. + + Checks (in order): + 1. URL contains /checkpoint or /authwall (security challenge) + 2. Page contains CAPTCHA iframe (bot detection) + 3. Body text contains rate-limit phrases on error-shaped pages (throttling) + + The body-text heuristic only runs on pages without a ``
`` element + and with short body text (<2000 chars), since real rate-limit pages are + minimal error pages. This avoids false positives from profile content + that happens to contain phrases like "slow down" or "try again later". + + Raises: + RateLimitError: If any rate-limiting or security challenge is detected + """ + # Check URL for security challenges + current_url = page.url + if "linkedin.com/checkpoint" in current_url or "authwall" in current_url: + raise RateLimitError( + "LinkedIn security checkpoint detected. " + "You may need to verify your identity or wait before continuing.", + suggested_wait_time=30, + ) + + # Check for CAPTCHA + try: + captcha = await page.locator( + 'iframe[title*="captcha" i], iframe[src*="captcha" i]' + ).count() + if captcha > 0: + raise RateLimitError( + "CAPTCHA challenge detected. Manual intervention required.", + suggested_wait_time=30, + ) + except RateLimitError: + raise + except PlaywrightTimeoutError: + pass + except Exception as e: + logger.debug("Error checking for CAPTCHA: %s", e) + + # Check for rate limit messages — only on error-shaped pages. + # Real rate-limit pages have no
element and short body text. + # Normal LinkedIn pages (profiles, jobs) have
and long content + # that may incidentally contain phrases like "slow down". + try: + has_main = await page.locator("main").count() > 0 + if has_main: + return # Normal page with content, skip body text heuristic + + body_text = await page.locator("body").inner_text(timeout=1000) + if body_text and len(body_text) < 2000: + body_lower = body_text.lower() + if any( + phrase in body_lower + for phrase in [ + "too many requests", + "rate limit", + "slow down", + "try again later", + ] + ): + raise RateLimitError( + "Rate limit message detected on page.", + suggested_wait_time=30, + ) + except RateLimitError: + raise + except PlaywrightTimeoutError: + pass + + +async def scroll_to_bottom( + page: Page, pause_time: float = 1.0, max_scrolls: int = 10 +) -> None: + """Scroll to the bottom of the page to trigger lazy loading. + + Args: + page: Patchright page object + pause_time: Time to pause between scrolls (seconds) + max_scrolls: Maximum number of scroll attempts + """ + for i in range(max_scrolls): + previous_height = await page.evaluate("document.body.scrollHeight") + await page.evaluate("window.scrollTo(0, document.body.scrollHeight)") + await asyncio.sleep(pause_time) + + new_height = await page.evaluate("document.body.scrollHeight") + if new_height == previous_height: + logger.debug("Reached bottom after %d scrolls", i + 1) + break + + +async def scroll_job_sidebar( + page: Page, pause_time: float = 1.0, max_scrolls: int = 10 +) -> None: + """Scroll the job search sidebar to load all job cards. + + LinkedIn renders job search results in a scrollable sidebar container, + not the main page body. This function finds that container by locating + a job card link and walking up to its scrollable ancestor, then scrolls + it iteratively until no new content loads. + + Args: + page: Patchright page object + pause_time: Time to pause between scrolls (seconds) + max_scrolls: Maximum number of scroll attempts + """ + # Wait for at least one job card link to render before scrolling + try: + await page.wait_for_selector('a[href*="/jobs/view/"]', timeout=5000) + except PlaywrightTimeoutError: + logger.debug("No job card links found, skipping sidebar scroll") + return + + scrolled = await page.evaluate( + """async ({pauseTime, maxScrolls}) => { + const link = document.querySelector('a[href*="/jobs/view/"]'); + if (!link) return -2; + + let container = link.parentElement; + while (container && container !== document.body) { + const style = window.getComputedStyle(container); + const overflowY = style.overflowY; + if ((overflowY === 'auto' || overflowY === 'scroll') + && container.scrollHeight > container.clientHeight) { + break; + } + container = container.parentElement; + } + + if (!container || container === document.body) { + return -1; + } + + let scrollCount = 0; + for (let i = 0; i < maxScrolls; i++) { + const prevHeight = container.scrollHeight; + container.scrollTop = container.scrollHeight; + await new Promise(r => setTimeout(r, pauseTime * 1000)); + if (container.scrollHeight === prevHeight) break; + scrollCount++; + } + return scrollCount; + }""", + {"pauseTime": pause_time, "maxScrolls": max_scrolls}, + ) + if scrolled == -2: + logger.debug("Job card link disappeared before evaluate, skipping scroll") + elif scrolled == -1: + logger.debug("No scrollable container found for job sidebar") + elif scrolled: + logger.debug("Scrolled job sidebar %d times", scrolled) + else: + logger.debug("Job sidebar container found but no new content loaded") + + +async def handle_modal_close(page: Page) -> bool: + """Close any popup modals that might be blocking content. + + Returns: + True if a modal was closed, False otherwise + """ + try: + close_button = page.locator( + 'button[aria-label="Dismiss"], ' + 'button[aria-label="Close"], ' + "button.artdeco-modal__dismiss" + ).first + + if await close_button.is_visible(timeout=1000): + await close_button.click() + await asyncio.sleep(0.5) + logger.debug("Closed modal") + return True + except PlaywrightTimeoutError: + pass + except Exception as e: + logger.debug("Error closing modal: %s", e) + + return False diff --git a/linkedin_mcp_server/debug_trace.py b/linkedin_mcp_server/debug_trace.py new file mode 100644 index 00000000..1bc76cfd --- /dev/null +++ b/linkedin_mcp_server/debug_trace.py @@ -0,0 +1,184 @@ +"""Best-effort trace capture with on-error retention.""" + +from __future__ import annotations + +import itertools +import json +import os +from pathlib import Path +import shutil +import tempfile +from typing import Any, Literal + +from linkedin_mcp_server.common_utils import slugify_fragment +from linkedin_mcp_server.session_state import auth_root_dir, get_source_profile_dir + +TraceMode = Literal["off", "on_error", "always"] + +_TRACE_COUNTER = itertools.count(1) +_TRACE_DIR: Path | None = None +_TRACE_KEEP = False +_EXPLICIT_TRACE_DIR = False + + +def _trace_mode() -> TraceMode: + raw = os.getenv("LINKEDIN_TRACE_MODE", "").strip().lower() + if raw in {"off", "false", "0", "no"}: + return "off" + if raw in {"always", "keep", "persist"}: + return "always" + return "on_error" + + +def _trace_root() -> Path: + source_profile = _safe_source_profile_dir() + root = auth_root_dir(source_profile) / "trace-runs" + root.mkdir(parents=True, exist_ok=True) + return root + + +def trace_enabled() -> bool: + return ( + bool(os.getenv("LINKEDIN_DEBUG_TRACE_DIR", "").strip()) + or _trace_mode() != "off" + ) + + +def get_trace_dir() -> Path | None: + global _TRACE_DIR, _EXPLICIT_TRACE_DIR + + explicit = os.getenv("LINKEDIN_DEBUG_TRACE_DIR", "").strip() + if explicit: + _EXPLICIT_TRACE_DIR = True + if _TRACE_DIR is None: + _TRACE_DIR = Path(explicit).expanduser().resolve() + return _TRACE_DIR + + if _trace_mode() == "off": + return None + + if _TRACE_DIR is None: + _TRACE_DIR = Path( + tempfile.mkdtemp( + prefix="run-", + dir=_trace_root(), + ) + ).resolve() + return _TRACE_DIR + + +def mark_trace_for_retention() -> Path | None: + global _TRACE_KEEP + trace_dir = get_trace_dir() + if trace_dir is not None: + trace_dir.mkdir(parents=True, exist_ok=True) + _TRACE_KEEP = True + return trace_dir + + +def should_keep_traces() -> bool: + return _EXPLICIT_TRACE_DIR or _TRACE_KEEP or _trace_mode() == "always" + + +def cleanup_trace_dir() -> None: + global _TRACE_DIR, _TRACE_KEEP, _EXPLICIT_TRACE_DIR + + trace_dir = _TRACE_DIR + if trace_dir is None or should_keep_traces(): + return + try: + shutil.rmtree(trace_dir) + except OSError: + return + _TRACE_DIR = None + _TRACE_KEEP = False + _EXPLICIT_TRACE_DIR = False + + +def reset_trace_state_for_testing() -> None: + global _TRACE_COUNTER, _TRACE_DIR, _TRACE_KEEP, _EXPLICIT_TRACE_DIR + _TRACE_COUNTER = itertools.count(1) + _TRACE_DIR = None + _TRACE_KEEP = False + _EXPLICIT_TRACE_DIR = False + + +def _slugify_step(step: str) -> str: + return slugify_fragment(step) + + +def _safe_source_profile_dir() -> Path: + try: + return get_source_profile_dir() + except Exception: + return Path("~/.linkedin-mcp/profile").expanduser() + + +async def record_page_trace( + page: Any, step: str, *, extra: dict[str, Any] | None = None +) -> None: + """Persist a screenshot and basic page state when trace capture is enabled.""" + trace_dir = get_trace_dir() + if trace_dir is None: + return + + trace_dir.mkdir(parents=True, exist_ok=True) + screenshot_dir = trace_dir / "screens" + screenshot_dir.mkdir(parents=True, exist_ok=True) + step_id = next(_TRACE_COUNTER) + slug = _slugify_step(step) or "step" + + try: + title = await page.title() + except Exception as exc: # pragma: no cover - best effort diagnostics + title = f"" + + try: + body_text = await page.evaluate("() => document.body?.innerText || ''") + except Exception as exc: # pragma: no cover - best effort diagnostics + body_text = f"" + + if not isinstance(body_text, str): + body_text = "" + + try: + remember_me = (await page.locator("#rememberme-div").count()) > 0 + except Exception: # pragma: no cover - best effort diagnostics + remember_me = False + + try: + cookies = await page.context.cookies() + except Exception: # pragma: no cover - best effort diagnostics + cookies = [] + + linkedin_cookie_names = sorted( + { + cookie["name"] + for cookie in cookies + if "linkedin.com" in cookie.get("domain", "") + } + ) + + screenshot_path = screenshot_dir / f"{step_id:03d}-{slug}.png" + screenshot: str | None = None + try: + await page.screenshot(path=str(screenshot_path), full_page=True) + screenshot = str(screenshot_path) + except Exception as exc: # pragma: no cover - best effort diagnostics + screenshot = f"" + + payload = { + "step_id": step_id, + "step": step, + "url": getattr(page, "url", ""), + "title": title, + "remember_me": remember_me, + "body_length": len(body_text), + "body_marker": " ".join(body_text.split())[:200], + "linkedin_cookie_names": linkedin_cookie_names, + "screenshot": screenshot, + "extra": extra or {}, + } + + with (trace_dir / "trace.jsonl").open("a", encoding="utf-8") as fh: + fh.write(json.dumps(payload, ensure_ascii=True) + "\n") diff --git a/linkedin_mcp_server/debug_utils.py b/linkedin_mcp_server/debug_utils.py new file mode 100644 index 00000000..b975f4b3 --- /dev/null +++ b/linkedin_mcp_server/debug_utils.py @@ -0,0 +1,35 @@ +"""Shared debug-only helpers for slower, traceable navigation flows.""" + +from __future__ import annotations + +import asyncio +import logging +import os + +_NAV_STABILIZE_DELAY_SECONDS = 5.0 + + +def debug_stabilize_navigation_enabled() -> bool: + """Return whether debug-only navigation stabilization sleeps are enabled.""" + return os.getenv("LINKEDIN_DEBUG_STABILIZE_NAVIGATION", "").strip().lower() in { + "1", + "true", + "yes", + "on", + } + + +async def stabilize_navigation(label: str, logger: logging.Logger) -> None: + """Pause between navigation steps to help debug timing-sensitive flows.""" + if ( + os.environ.get("PYTEST_CURRENT_TEST") + or not debug_stabilize_navigation_enabled() + ): + return + + logger.debug( + "Stabilizing navigation for %.1fs after %s", + _NAV_STABILIZE_DELAY_SECONDS, + label, + ) + await asyncio.sleep(_NAV_STABILIZE_DELAY_SECONDS) diff --git a/linkedin_mcp_server/dependencies.py b/linkedin_mcp_server/dependencies.py new file mode 100644 index 00000000..d6c0bda4 --- /dev/null +++ b/linkedin_mcp_server/dependencies.py @@ -0,0 +1,22 @@ +"""Dependency injection factories for MCP tools.""" + +from linkedin_mcp_server.drivers.browser import ( + ensure_authenticated, + get_or_create_browser, +) +from linkedin_mcp_server.error_handler import raise_tool_error +from linkedin_mcp_server.scraping import LinkedInExtractor + + +async def get_extractor() -> LinkedInExtractor: + """Acquire the singleton browser, authenticate, and return a ready extractor. + + Known LinkedIn exceptions are converted to structured ToolError responses + via raise_tool_error(); unexpected exceptions propagate as-is. + """ + try: + browser = await get_or_create_browser() + await ensure_authenticated() + return LinkedInExtractor(browser.page) + except Exception as e: + raise_tool_error(e, "get_extractor") # NoReturn diff --git a/linkedin_mcp_server/drivers/__init__.py b/linkedin_mcp_server/drivers/__init__.py new file mode 100644 index 00000000..7b287cc2 --- /dev/null +++ b/linkedin_mcp_server/drivers/__init__.py @@ -0,0 +1,40 @@ +""" +Browser management package for LinkedIn scraping. + +This package provides Patchright browser management using linkedin_scraper v3's +BrowserManager with persistent context. It implements a singleton pattern for +browser instances to ensure profile persistence across multiple tool calls +while handling authentication and proper resource cleanup. + +Key Components: +- Patchright browser initialization via BrowserManager with persistent profile +- LinkedIn authentication with automatic profile persistence +- Singleton pattern for browser reuse across tools +- Automatic cleanup and resource management +""" + +from linkedin_mcp_server.drivers.browser import ( + DEFAULT_PROFILE_DIR, + check_rate_limit, + close_browser, + ensure_authenticated, + get_or_create_browser, + get_profile_dir, + profile_exists, + reset_browser_for_testing, + set_headless, + validate_session, +) + +__all__ = [ + "DEFAULT_PROFILE_DIR", + "check_rate_limit", + "close_browser", + "ensure_authenticated", + "get_or_create_browser", + "get_profile_dir", + "profile_exists", + "reset_browser_for_testing", + "set_headless", + "validate_session", +] diff --git a/linkedin_mcp_server/drivers/browser.py b/linkedin_mcp_server/drivers/browser.py new file mode 100644 index 00000000..a19cf832 --- /dev/null +++ b/linkedin_mcp_server/drivers/browser.py @@ -0,0 +1,569 @@ +""" +Patchright browser management for LinkedIn scraping. + +Provides async browser lifecycle management using BrowserManager with persistent +context. Implements a singleton pattern for browser reuse across tool calls with +automatic profile persistence. +""" + +import logging +import os +from pathlib import Path + +from linkedin_mcp_server.core import ( + AuthenticationError, + BrowserManager, + detect_auth_barrier_quick, + detect_rate_limit, + is_logged_in, + resolve_remember_me_prompt, +) + +from linkedin_mcp_server.common_utils import utcnow_iso +from linkedin_mcp_server.config import get_config +from linkedin_mcp_server.debug_trace import record_page_trace +from linkedin_mcp_server.debug_utils import stabilize_navigation +from linkedin_mcp_server.session_state import ( + SourceState, + clear_runtime_profile, + get_runtime_id, + get_source_profile_dir, + load_runtime_state, + load_source_state, + portable_cookie_path, + profile_exists as session_profile_exists, + runtime_profile_dir, + runtime_storage_state_path, + write_runtime_state, +) + +logger = logging.getLogger(__name__) + + +# Default persistent profile directory +DEFAULT_PROFILE_DIR = Path.home() / ".linkedin-mcp" / "profile" +# Global browser instance (singleton) +_browser: BrowserManager | None = None +_browser_cookie_export_path: Path | None = None +_headless: bool = True + + +def _debug_skip_checkpoint_restart() -> bool: + """Return whether to keep the fresh bridged browser alive for this run.""" + return os.getenv("LINKEDIN_DEBUG_SKIP_CHECKPOINT_RESTART", "").strip().lower() in { + "1", + "true", + "yes", + "on", + } + + +def _debug_bridge_every_startup() -> bool: + """Return whether to force a fresh bridge on every foreign-runtime startup.""" + return os.getenv("LINKEDIN_DEBUG_BRIDGE_EVERY_STARTUP", "").strip().lower() in { + "1", + "true", + "yes", + "on", + } + + +def experimental_persist_derived_runtime() -> bool: + """Return whether Docker-style foreign runtimes should reuse derived profiles.""" + return os.getenv( + "LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "" + ).strip().lower() in { + "1", + "true", + "yes", + "on", + } + + +def _apply_browser_settings(browser: BrowserManager) -> None: + """Apply configuration settings to browser instance.""" + config = get_config() + browser.page.set_default_timeout(config.browser.default_timeout) + + +async def _log_feed_failure_context( + browser: BrowserManager, + reason: str, + exc: Exception | None = None, +) -> None: + """Log the page state when /feed/ validation fails.""" + page = browser.page + + try: + title = await page.title() + except Exception: + title = "" + + try: + remember_me = (await page.locator("#rememberme-div").count()) > 0 + except Exception: + remember_me = False + + try: + body_text = await page.evaluate("() => document.body?.innerText || ''") + except Exception: + body_text = "" + + if not isinstance(body_text, str): + body_text = "" + + logger.warning( + "Feed auth check failed on %s: %s title=%r remember_me=%s body_marker=%r", + page.url, + reason, + title, + remember_me, + " ".join(body_text.split())[:200], + exc_info=exc, + ) + + +async def _feed_auth_succeeds( + browser: BrowserManager, + *, + allow_remember_me: bool = True, +) -> bool: + """Validate that /feed/ loads without an auth barrier.""" + try: + await browser.page.goto( + "https://www.linkedin.com/feed/", + wait_until="domcontentloaded", + ) + await stabilize_navigation("feed navigation", logger) + await record_page_trace( + browser.page, + "feed-after-goto", + extra={"allow_remember_me": allow_remember_me}, + ) + if allow_remember_me: + if await resolve_remember_me_prompt(browser.page): + await stabilize_navigation("remember-me resolution", logger) + await record_page_trace( + browser.page, + "feed-after-remember-me", + extra={"allow_remember_me": allow_remember_me}, + ) + return await _feed_auth_succeeds(browser, allow_remember_me=False) + barrier = await detect_auth_barrier_quick(browser.page) + if barrier is not None: + await record_page_trace( + browser.page, + "feed-auth-barrier", + extra={"barrier": barrier}, + ) + await _log_feed_failure_context(browser, barrier) + return False + return True + except Exception as exc: + if allow_remember_me and await resolve_remember_me_prompt(browser.page): + await stabilize_navigation( + "remember-me resolution after feed failure", logger + ) + await record_page_trace( + browser.page, + "feed-after-remember-me-error-recovery", + extra={"error": f"{type(exc).__name__}: {exc}"}, + ) + return await _feed_auth_succeeds(browser, allow_remember_me=False) + await record_page_trace( + browser.page, + "feed-navigation-error", + extra={"error": f"{type(exc).__name__}: {exc}"}, + ) + await _log_feed_failure_context(browser, str(exc), exc) + return False + + +def _launch_options() -> tuple[dict[str, str], dict[str, int]]: + config = get_config() + viewport = { + "width": config.browser.viewport_width, + "height": config.browser.viewport_height, + } + launch_options: dict[str, str] = {} + if config.browser.chrome_path: + launch_options["executable_path"] = config.browser.chrome_path + logger.info("Using custom Chrome path: %s", config.browser.chrome_path) + return launch_options, viewport + + +def _make_browser( + profile_dir: Path, + *, + launch_options: dict[str, str], + viewport: dict[str, int], +) -> BrowserManager: + config = get_config() + return BrowserManager( + user_data_dir=profile_dir, + headless=_headless, + slow_mo=config.browser.slow_mo, + user_agent=config.browser.user_agent, + viewport=viewport, + **launch_options, + ) + + +async def _authenticate_existing_profile( + profile_dir: Path, + *, + launch_options: dict[str, str], + viewport: dict[str, int], +) -> BrowserManager: + browser = _make_browser( + profile_dir, launch_options=launch_options, viewport=viewport + ) + try: + await browser.start() + if not await _feed_auth_succeeds(browser): + raise AuthenticationError( + f"Stored runtime profile is invalid: {profile_dir}. Run with --login to refresh the source session." + ) + browser.is_authenticated = True + return browser + except Exception: + await browser.close() + raise + + +async def _bridge_runtime_profile( + profile_dir: Path, + *, + cookie_path: Path, + source_state: SourceState, + runtime_id: str, + launch_options: dict[str, str], + viewport: dict[str, int], + persist_runtime: bool, +) -> BrowserManager: + source_profile_dir = get_source_profile_dir() + bridge_started_at = utcnow_iso() + clear_runtime_profile(runtime_id, source_profile_dir) + profile_dir.parent.mkdir(parents=True, exist_ok=True) + storage_state_path = runtime_storage_state_path(runtime_id, source_profile_dir) + browser = _make_browser( + profile_dir, launch_options=launch_options, viewport=viewport + ) + try: + await browser.start() + await record_page_trace( + browser.page, + "bridge-browser-started", + extra={"profile_dir": str(profile_dir)}, + ) + await browser.page.goto( + "https://www.linkedin.com/feed/", wait_until="domcontentloaded" + ) + await stabilize_navigation("pre-import feed navigation", logger) + await record_page_trace(browser.page, "bridge-after-pre-import-feed") + if not await browser.import_cookies(cookie_path): + raise AuthenticationError( + "Portable authentication could not be imported. Run with --login to create a fresh source session." + ) + await stabilize_navigation("bridge cookie import", logger) + await record_page_trace( + browser.page, + "bridge-after-cookie-import", + extra={"cookie_path": str(cookie_path)}, + ) + if not await _feed_auth_succeeds(browser): + raise AuthenticationError( + "No authentication found. Run with --login to create a profile." + ) + await stabilize_navigation("post-import feed validation", logger) + await record_page_trace(browser.page, "bridge-after-feed-validation") + if not persist_runtime: + logger.info( + "Foreign runtime %s authenticated via fresh bridge " + "(derived runtime persistence disabled)", + runtime_id, + ) + browser.is_authenticated = True + return browser + if _debug_skip_checkpoint_restart(): + logger.warning( + "Skipping checkpoint restart for derived runtime profile %s " + "(LINKEDIN_DEBUG_SKIP_CHECKPOINT_RESTART enabled)", + profile_dir, + ) + browser.is_authenticated = True + return browser + if not await browser.export_storage_state(storage_state_path, indexed_db=True): + raise AuthenticationError( + "Derived runtime session could not be checkpointed. Run with --login to create a fresh source session." + ) + await stabilize_navigation("runtime storage-state export", logger) + logger.info("Checkpoint-restarting derived runtime profile %s", profile_dir) + await browser.close() + reopened = _make_browser( + profile_dir, + launch_options=launch_options, + viewport=viewport, + ) + try: + await reopened.start() + await stabilize_navigation("derived profile reopen", logger) + await record_page_trace( + reopened.page, + "bridge-after-profile-reopen", + extra={"profile_dir": str(profile_dir)}, + ) + if not await _feed_auth_succeeds(reopened): + logger.warning( + "Stored derived runtime profile failed post-commit validation" + ) + raise AuthenticationError( + "Derived runtime validation failed; no automatic re-bridge will be attempted. Run with --login to create a fresh source session." + ) + await stabilize_navigation("post-reopen feed validation", logger) + await record_page_trace(reopened.page, "bridge-after-reopen-validation") + write_runtime_state( + runtime_id, + source_state, + storage_state_path, + source_profile_dir, + created_at=bridge_started_at, + ) + logger.info("Derived runtime profile committed for %s", runtime_id) + reopened.is_authenticated = True + return reopened + except Exception: + await reopened.close() + raise + except Exception: + await browser.close() + clear_runtime_profile(runtime_id, source_profile_dir) + raise + + +async def get_or_create_browser( + headless: bool | None = None, +) -> BrowserManager: + """ + Get existing browser or create and initialize a new one. + + Uses a singleton pattern to reuse the browser across tool calls. + Uses persistent context for automatic profile persistence. + + Args: + headless: Run browser in headless mode. Defaults to config value. + + Returns: + Initialized BrowserManager instance + + Raises: + AuthenticationError: If no valid authentication found + """ + global _browser, _browser_cookie_export_path, _headless + + if headless is not None: + _headless = headless + + if _browser is not None: + return _browser + + launch_options, viewport = _launch_options() + source_profile_dir = get_profile_dir() + cookie_path = portable_cookie_path(source_profile_dir) + source_state = load_source_state(source_profile_dir) + if ( + not source_state + or not profile_exists(source_profile_dir) + or not cookie_path.exists() + ): + raise AuthenticationError( + "No source authentication found. Run with --login to create a profile." + ) + + current_runtime_id = get_runtime_id() + + if current_runtime_id == source_state.source_runtime_id: + logger.info( + "Using source profile for runtime %s (profile=%s)", + current_runtime_id, + source_profile_dir, + ) + browser = await _authenticate_existing_profile( + source_profile_dir, + launch_options=launch_options, + viewport=viewport, + ) + _apply_browser_settings(browser) + _browser = browser + _browser_cookie_export_path = cookie_path + return _browser + + persist_runtime = experimental_persist_derived_runtime() + force_bridge = _debug_bridge_every_startup() + + if not persist_runtime: + logger.info( + "Using fresh bridge for foreign runtime %s " + "(derived runtime persistence disabled by default)", + current_runtime_id, + ) + browser = await _bridge_runtime_profile( + runtime_profile_dir(current_runtime_id, source_profile_dir), + cookie_path=cookie_path, + source_state=source_state, + runtime_id=current_runtime_id, + launch_options=launch_options, + viewport=viewport, + persist_runtime=False, + ) + _apply_browser_settings(browser) + _browser = browser + _browser_cookie_export_path = None + return _browser + + runtime_state = load_runtime_state(current_runtime_id, source_profile_dir) + derived_profile_dir = runtime_profile_dir(current_runtime_id, source_profile_dir) + storage_state_path = runtime_storage_state_path( + current_runtime_id, source_profile_dir + ) + generation_matches = ( + runtime_state is not None + and runtime_state.source_login_generation == source_state.login_generation + ) + if ( + not force_bridge + and generation_matches + and profile_exists(derived_profile_dir) + and storage_state_path.exists() + ): + logger.info( + "Using derived runtime profile for %s (profile=%s)", + current_runtime_id, + derived_profile_dir, + ) + try: + browser = await _authenticate_existing_profile( + derived_profile_dir, + launch_options=launch_options, + viewport=viewport, + ) + _apply_browser_settings(browser) + _browser = browser + _browser_cookie_export_path = None + return _browser + except AuthenticationError: + logger.warning( + "Derived runtime profile auth failed for %s; re-bridging from source cookies", + current_runtime_id, + ) + + if force_bridge: + logger.warning( + "Forcing a fresh bridge for %s on every startup " + "(LINKEDIN_DEBUG_BRIDGE_EVERY_STARTUP enabled)", + current_runtime_id, + ) + logger.info( + "Deriving runtime profile for %s from source generation %s", + current_runtime_id, + source_state.login_generation, + ) + browser = await _bridge_runtime_profile( + derived_profile_dir, + cookie_path=cookie_path, + source_state=source_state, + runtime_id=current_runtime_id, + launch_options=launch_options, + viewport=viewport, + persist_runtime=True, + ) + _apply_browser_settings(browser) + _browser = browser + _browser_cookie_export_path = None + return _browser + + +async def close_browser() -> None: + """Close the browser and cleanup resources.""" + global _browser, _browser_cookie_export_path + + browser = _browser + cookie_export_path = _browser_cookie_export_path + _browser = None + _browser_cookie_export_path = None + + if browser is None: + return + + logger.info("Closing browser...") + if cookie_export_path is not None: + try: + await browser.export_cookies(cookie_export_path) + except Exception: + logger.debug("Cookie export on close skipped", exc_info=True) + await browser.close() + logger.info("Browser closed") + + +def get_profile_dir() -> Path: + """Get the resolved profile directory from config.""" + return get_source_profile_dir() + + +def profile_exists(profile_dir: Path | None = None) -> bool: + """Check if a persistent browser profile exists and is non-empty.""" + return session_profile_exists(profile_dir or get_profile_dir()) + + +def set_headless(headless: bool) -> None: + """Set headless mode for future browser creation.""" + global _headless + _headless = headless + + +async def validate_session() -> bool: + """ + Check whether startup authentication has already succeeded for this browser. + + Mid-session expiry is detected during real LinkedIn navigations and scraper + auth checks rather than via a fresh login probe on every tool call. + + Returns: + True if startup authentication succeeded for the current browser + """ + browser = await get_or_create_browser() + if browser.is_authenticated: + return True + return await is_logged_in(browser.page) + + +async def ensure_authenticated() -> None: + """ + Confirm that the shared browser completed startup authentication. + + Raises: + AuthenticationError: If no authenticated browser session is available + """ + if not await validate_session(): + raise AuthenticationError("Session expired or invalid.") + + +async def check_rate_limit() -> None: + """ + Proactively check for rate limiting. + + Should be called after navigation to detect if LinkedIn is blocking requests. + + Raises: + RateLimitError: If rate limiting is detected + """ + browser = await get_or_create_browser() + await detect_rate_limit(browser.page) + + +def reset_browser_for_testing() -> None: + """Reset global browser state for test isolation.""" + global _browser, _browser_cookie_export_path, _headless + _browser = None + _browser_cookie_export_path = None + _headless = True diff --git a/linkedin_mcp_server/error_diagnostics.py b/linkedin_mcp_server/error_diagnostics.py new file mode 100644 index 00000000..6c46b46f --- /dev/null +++ b/linkedin_mcp_server/error_diagnostics.py @@ -0,0 +1,408 @@ +"""Issue-ready diagnostics for scraper failures.""" + +from __future__ import annotations + +import asyncio +from dataclasses import asdict +import json +import socket +from pathlib import Path +from typing import Any +from urllib.parse import quote_plus +from urllib.request import Request, urlopen + +from linkedin_mcp_server.common_utils import slugify_fragment, utcnow_iso +from linkedin_mcp_server.debug_trace import get_trace_dir, mark_trace_for_retention +from linkedin_mcp_server.session_state import ( + auth_root_dir, + get_runtime_id, + get_source_profile_dir, + load_runtime_state, + load_source_state, + portable_cookie_path, + runtime_profile_dir, + runtime_storage_state_path, +) + +ISSUE_URL = "https://github.com/stickerdaniel/linkedin-mcp-server/issues/new/choose" +ISSUE_TITLE_PREFIX = "[BUG]" +ISSUE_SEARCH_API = "https://api.github.com/search/issues" + + +def build_issue_diagnostics( + exception: Exception, + *, + context: str, + target_url: str | None = None, + section_name: str | None = None, +) -> dict[str, Any]: + """Write an issue-ready report and return MCP-safe diagnostics.""" + timestamp = utcnow_iso() + source_profile_dir = _safe_source_profile_dir() + current_runtime_id = get_runtime_id() + source_state = load_source_state(source_profile_dir) + runtime_state = load_runtime_state(current_runtime_id, source_profile_dir) + trace_dir = mark_trace_for_retention() or get_trace_dir() + log_path = trace_dir / "server.log" if trace_dir else None + issue_dir = trace_dir or (auth_root_dir(source_profile_dir) / "issue-reports") + issue_dir.mkdir(parents=True, exist_ok=True) + issue_path = ( + issue_dir + / f"{timestamp.replace(':', '').replace('-', '')}-{slugify_fragment(context) or 'issue'}.md" + ) + gist_command = _build_gist_command(issue_dir, issue_path, log_path) + + runtime_details = { + "hostname": socket.gethostname(), + "current_runtime_id": current_runtime_id, + "source_profile_dir": str(source_profile_dir), + "portable_cookie_path": str(portable_cookie_path(source_profile_dir)), + "source_state": asdict(source_state) if source_state else None, + "runtime_profile_dir": str( + runtime_profile_dir(current_runtime_id, source_profile_dir) + ), + "runtime_storage_state_path": str( + runtime_storage_state_path(current_runtime_id, source_profile_dir) + ), + "runtime_state": asdict(runtime_state) if runtime_state else None, + "trace_dir": str(trace_dir) if trace_dir else None, + "log_path": str(log_path) if log_path and log_path.exists() else None, + "suggested_gist_command": gist_command, + } + payload = { + "created_at": timestamp, + "context": context, + "section_name": section_name, + "target_url": target_url, + "error_type": type(exception).__name__, + "error_message": str(exception), + "runtime": runtime_details, + "suggested_issue_title": _suggest_issue_title( + context=context, + section_name=section_name, + target_url=target_url, + current_runtime_id=current_runtime_id, + ), + } + payload["issue_search_skipped"] = _inside_running_event_loop() + if payload["issue_search_skipped"]: + payload["existing_issues"] = [] + else: + payload["existing_issues"] = _find_existing_issues(payload) + issue_template = _render_issue_template(payload) + issue_path.write_text(issue_template) + return _public_issue_diagnostics(payload, issue_path=issue_path) + + +def format_tool_error_with_diagnostics( + message: str, diagnostics: dict[str, Any] +) -> str: + """Append issue-report locations to a tool-facing error message.""" + lines = [message, "", "Diagnostics:"] + if diagnostics.get("issue_template_path"): + lines.append(f"- Issue template: {diagnostics['issue_template_path']}") + runtime = diagnostics.get("runtime") or {} + if runtime.get("trace_dir"): + lines.append(f"- Trace artifacts: {runtime['trace_dir']}") + if runtime.get("log_path"): + lines.append(f"- Server log: {runtime['log_path']}") + if runtime.get("suggested_gist_command"): + lines.append(f"- Suggested gist command: {runtime['suggested_gist_command']}") + lines.append(f"- Runtime: {runtime.get('current_runtime_id', 'unknown')}") + existing_issues = diagnostics.get("existing_issues") or [] + if existing_issues: + lines.append("- Matching open issues were found. Review them first:") + for issue in existing_issues: + lines.append(f" - #{issue['number']}: {issue['title']} ({issue['url']})") + lines.append( + "- If one matches this failure, upload the gist and post it as a comment on that issue instead of opening a new issue." + ) + else: + if diagnostics.get("issue_search_skipped"): + lines.append( + "- Matching open-issue search was skipped in async server context to avoid blocking the server event loop." + ) + lines.append(f"- File the issue here: {ISSUE_URL}") + lines.append( + "- Read the generated issue template and attach the listed files before posting." + ) + return "\n".join(lines) + + +def _render_issue_template(payload: dict[str, Any]) -> str: + runtime = payload["runtime"] + existing_issues = payload.get("existing_issues") or [] + has_existing_issues = bool(existing_issues) + issue_search_skipped = bool(payload.get("issue_search_skipped")) + installation_lines = _installation_method_lines(runtime) + tool_lines = _tool_lines(payload) + return ( + "\n".join( + [ + "# LinkedIn MCP scrape failure", + "", + "## File This Issue", + f"- Suggested title: {payload['suggested_issue_title']}", + "- Read this generated file before posting.", + "- Copy the sections below into the GitHub bug report template.", + "- Attach this generated markdown file, the server log, and the trace artifacts directory.", + ( + "- Review the existing open issues below first. If one matches, post the gist as a comment there instead of opening a new issue." + if has_existing_issues + else f"- GitHub issue link: {ISSUE_URL}" + ), + "", + "## Existing Open Issues", + *( + [ + f"- #{issue['number']}: {issue['title']} ({issue['url']})" + for issue in existing_issues + ] + if has_existing_issues + else ( + [ + "- Matching open-issue search was skipped in async server context to avoid blocking the server event loop." + ] + if issue_search_skipped + else ["- No matching open issues found during diagnostics."] + ) + ), + "", + "## Installation Method", + *installation_lines, + "", + "## When does the error occur?", + "- [ ] At startup", + "- [x] During tool call (specify which tool):", + *tool_lines, + "", + "## MCP Client Configuration", + "", + "**Client used for reproduction**:", + "```text", + "Local curl-based MCP HTTP client against the server's streamable-http transport", + "```", + "", + "## MCP Client Logs", + "```text", + "See attached server log and trace artifacts.", + "```", + "", + "## Error Description", + f"Context: {payload['context']}", + f"Section: {payload.get('section_name') or 'n/a'}", + f"Target URL: {payload.get('target_url') or 'n/a'}", + f"Error: {payload['error_type']}: {payload['error_message']}", + "", + "## Runtime Diagnostics", + f"- Hostname: {runtime['hostname']}", + f"- Current runtime: {runtime['current_runtime_id']}", + f"- Source profile: {runtime['source_profile_dir']}", + f"- Portable cookies: {runtime['portable_cookie_path']}", + f"- Derived runtime profile: {runtime['runtime_profile_dir']}", + f"- Derived storage-state: {runtime['runtime_storage_state_path']}", + f"- Trace artifacts: {runtime['trace_dir'] or 'not enabled'}", + f"- Server log: {runtime['log_path'] or 'not enabled'}", + f"- Suggested gist command: {runtime['suggested_gist_command'] or 'not available'}", + "", + "## Session State", + "```json", + json.dumps( + { + "source_state": runtime["source_state"], + "runtime_state": runtime["runtime_state"], + }, + indent=2, + sort_keys=True, + ), + "```", + "", + "## Attachment Checklist", + "- Read this generated markdown file and use it as the issue body/context.", + "- Attach this generated markdown file itself.", + "- Attach the server log if available.", + "- Attach the trace screenshots/trace.jsonl if available.", + "- Optional: run the suggested gist command below to upload the text artifacts as a single shareable bundle.", + "", + "## Suggested Gist Command", + "```bash", + runtime["suggested_gist_command"] or "# gist command unavailable", + "```", + "", + "## Reproduction", + "1. Run a fresh local `uv run -m linkedin_mcp_server --login`.", + "2. Start the server again using the same installation method and debug env vars used for this run.", + "3. Re-run the failing MCP tool call.", + ( + "4. If one of the listed open issues matches, post the gist as a comment there as additional information." + if has_existing_issues + else "4. If no existing issue matches, open a new GitHub bug report with the information above." + ), + ] + ) + + "\n" + ) + + +def _public_issue_diagnostics( + payload: dict[str, Any], *, issue_path: Path +) -> dict[str, Any]: + runtime = payload["runtime"] + return { + "created_at": payload["created_at"], + "context": payload["context"], + "section_name": payload["section_name"], + "target_url": payload["target_url"], + "error_type": payload["error_type"], + "error_message": payload["error_message"], + "suggested_issue_title": payload["suggested_issue_title"], + "existing_issues": payload["existing_issues"], + "issue_search_skipped": payload["issue_search_skipped"], + "issue_template_path": str(issue_path), + "runtime": { + "current_runtime_id": runtime["current_runtime_id"], + "trace_dir": runtime["trace_dir"], + "log_path": runtime["log_path"], + "suggested_gist_command": runtime["suggested_gist_command"], + }, + } + + +def _safe_source_profile_dir(): + try: + return get_source_profile_dir() + except Exception: + return (Path.home() / ".linkedin-mcp" / "profile").expanduser() + + +def _suggest_issue_title( + *, + context: str, + section_name: str | None, + target_url: str | None, + current_runtime_id: str, +) -> str: + section = section_name or "unknown-section" + route = target_url or context + if "/recent-activity/" in route: + summary = f"recent-activity redirect loop in {section} on {current_runtime_id}" + else: + summary = f"{section} scrape failure in {context} on {current_runtime_id}" + return f"{ISSUE_TITLE_PREFIX} {summary}" + + +def _build_gist_command( + issue_dir: Path, + issue_path: Path, + log_path: Path | None, +) -> str: + trace_path = issue_dir / "trace.jsonl" + files = [str(issue_path)] + if log_path is not None and log_path.exists(): + files.append(str(log_path)) + if trace_path.exists(): + files.append(str(trace_path)) + quoted = " ".join(f'"{path}"' for path in files) + return f'gh gist create {quoted} -d "LinkedIn MCP debug artifacts"' + + +def _find_existing_issues(payload: dict[str, Any]) -> list[dict[str, Any]]: + query = _issue_search_query(payload) + if not query: + return [] + + request = Request( + f"{ISSUE_SEARCH_API}?q={quote_plus(query)}&per_page=3", + headers={ + "Accept": "application/vnd.github+json", + "User-Agent": "linkedin-mcp-server-diagnostics", + }, + ) + try: + with urlopen(request, timeout=3) as response: + data = json.loads(response.read().decode("utf-8")) + except Exception: + return [] + + issues: list[dict[str, Any]] = [] + for item in data.get("items", []): + issues.append( + { + "number": item.get("number"), + "title": item.get("title"), + "url": item.get("html_url"), + } + ) + return issues + + +def _inside_running_event_loop() -> bool: + try: + asyncio.get_running_loop() + except RuntimeError: + return False + return True + + +def _installation_method_lines(runtime: dict[str, Any]) -> list[str]: + current_runtime_id = str(runtime.get("current_runtime_id") or "") + docker_checked = "x" if "container" in current_runtime_id else " " + return [ + f"- [{docker_checked}] Docker (specify docker image version/tag): `stickerdaniel/linkedin-mcp-server:latest` with `~/.linkedin-mcp` mounted into `/home/pwuser/.linkedin-mcp`", + "- [ ] Claude Desktop DXT extension (specify docker image version/tag): _._._", + "- [ ] Local Python setup", + ] + + +def _tool_lines(payload: dict[str, Any]) -> list[str]: + selected_tool = _tool_name_for_context(payload) + tool_names = [ + "get_person_profile", + "get_company_profile", + "get_company_posts", + "get_job_details", + "search_jobs", + "search_people", + "close_session", + ] + return [ + f" - [{'x' if tool_name == selected_tool else ' '}] {tool_name}" + for tool_name in tool_names + ] + + +def _tool_name_for_context(payload: dict[str, Any]) -> str | None: + context = str(payload.get("context") or "") + if context in { + "get_person_profile", + "get_company_profile", + "get_company_posts", + "get_job_details", + "search_jobs", + "search_people", + "close_session", + }: + return context + + if context in {"extract_page", "extract_overlay", "scrape_person"}: + return "get_person_profile" + if context == "scrape_company": + return "get_company_profile" + if context == "extract_search_page": + target_url = str(payload.get("target_url") or "") + if "/search/results/people" in target_url: + return "search_people" + if "/jobs/search" in target_url: + return "search_jobs" + + return None + + +def _issue_search_query(payload: dict[str, Any]) -> str: + route = payload.get("target_url") or payload.get("context") or "" + if "/recent-activity/" in route: + summary = '"recent-activity redirect loop"' + else: + section = payload.get("section_name") or "scrape" + summary = f'"{section}"' + return f"repo:stickerdaniel/linkedin-mcp-server is:issue is:open {summary}" diff --git a/linkedin_mcp_server/error_handler.py b/linkedin_mcp_server/error_handler.py new file mode 100644 index 00000000..c245ecbf --- /dev/null +++ b/linkedin_mcp_server/error_handler.py @@ -0,0 +1,144 @@ +""" +Centralized error handling for LinkedIn MCP Server using FastMCP ToolError. + +Provides raise_tool_error() which maps known LinkedIn exceptions to user-friendly +ToolError messages. Unknown exceptions are re-raised as-is for mask_error_details +to handle. +""" + +import logging +from typing import NoReturn + +from fastmcp.exceptions import ToolError + +from linkedin_mcp_server.core.exceptions import ( + AuthenticationError, + ElementNotFoundError, + LinkedInScraperException, + NetworkError, + ProfileNotFoundError, + RateLimitError, + ScrapingError, +) + +from linkedin_mcp_server.exceptions import ( + CredentialsNotFoundError, + LinkedInMCPError, + SessionExpiredError, +) +from linkedin_mcp_server.error_diagnostics import ( + build_issue_diagnostics, + format_tool_error_with_diagnostics, +) + +logger = logging.getLogger(__name__) + + +def _raise_tool_error_with_diagnostics( + exception: Exception, + message: str, + *, + context: str, +) -> NoReturn: + try: + diagnostics = build_issue_diagnostics(exception, context=context) + except Exception: + logger.debug("Could not build issue diagnostics", exc_info=True) + diagnostics = None + + if diagnostics is not None: + message = format_tool_error_with_diagnostics(message, diagnostics) + raise ToolError(message) from exception + + +def raise_tool_error(exception: Exception, context: str = "") -> NoReturn: + """ + Raise a ToolError for known LinkedIn exceptions, or re-raise unknown ones. + + Known exceptions are mapped to user-friendly messages via ToolError. + Unknown exceptions are re-raised as-is so mask_error_details can mask them. + + Args: + exception: The exception that occurred + context: Optional context about which tool failed (for log correlation) + + Raises: + ToolError: For known LinkedIn exception types + Exception: Re-raises unknown exceptions as-is + """ + ctx = f" in {context}" if context else "" + + if isinstance(exception, CredentialsNotFoundError): + logger.warning("Credentials not found%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + "Authentication not found. Run with --login to create a browser profile.", + context=context, + ) + + elif isinstance(exception, SessionExpiredError): + logger.warning("Session expired%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + "Session expired. Run with --login to create a new browser profile.", + context=context, + ) + + elif isinstance(exception, AuthenticationError): + logger.warning("Authentication failed%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + "Authentication failed. Run with --login to re-authenticate.", + context=context, + ) + + elif isinstance(exception, RateLimitError): + wait_time = getattr(exception, "suggested_wait_time", 300) + logger.warning("Rate limit%s: %s (wait=%ds)", ctx, exception, wait_time) + raise ToolError( + f"Rate limit detected. Wait {wait_time} seconds before trying again." + ) from exception + + elif isinstance(exception, ProfileNotFoundError): + logger.warning("Profile not found%s: %s", ctx, exception) + raise ToolError( + "Profile not found. Check the profile URL is correct." + ) from exception + + elif isinstance(exception, ElementNotFoundError): + logger.warning("Element not found%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + "Element not found. LinkedIn page structure may have changed.", + context=context, + ) + + elif isinstance(exception, NetworkError): + logger.warning("Network error%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + "Network error. Check your connection and try again.", + context=context, + ) + + elif isinstance(exception, ScrapingError): + logger.warning("Scraping error%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + "Scraping failed. LinkedIn page structure may have changed.", + context=context, + ) + + elif isinstance(exception, (LinkedInScraperException, LinkedInMCPError)): + # Catch-all for base exception types and any future subclasses + # without a dedicated handler above. Passes through str(exception). + logger.warning("LinkedIn error%s: %s", ctx, exception) + _raise_tool_error_with_diagnostics( + exception, + str(exception), + context=context, + ) + + else: + logger.error("Unexpected error%s: %s", ctx, exception, exc_info=True) + raise exception diff --git a/linkedin_mcp_server/exceptions.py b/linkedin_mcp_server/exceptions.py new file mode 100644 index 00000000..b06b49d8 --- /dev/null +++ b/linkedin_mcp_server/exceptions.py @@ -0,0 +1,31 @@ +# src/linkedin_mcp_server/exceptions.py +""" +Custom exceptions for LinkedIn MCP Server with specific error categorization. + +Defines hierarchical exception types for different error scenarios including +authentication failures and MCP client reporting. +""" + + +class LinkedInMCPError(Exception): + """Base exception for LinkedIn MCP Server.""" + + pass + + +class CredentialsNotFoundError(LinkedInMCPError): + """No credentials available in non-interactive mode.""" + + pass + + +class SessionExpiredError(LinkedInMCPError): + """Session has expired and needs to be refreshed.""" + + def __init__(self, message: str | None = None): + default_msg = ( + "LinkedIn session has expired.\n\n" + "To fix this:\n" + " Run with --login to create a new session" + ) + super().__init__(message or default_msg) diff --git a/linkedin_mcp_server/logging_config.py b/linkedin_mcp_server/logging_config.py new file mode 100644 index 00000000..d5be160c --- /dev/null +++ b/linkedin_mcp_server/logging_config.py @@ -0,0 +1,157 @@ +# linkedin_mcp_server/logging_config.py +""" +Logging configuration for LinkedIn MCP Server with format options. + +Provides JSON and compact logging formats for different deployment scenarios. +JSON format for production MCP integration, compact format for development. +Includes proper logger hierarchy and external library noise reduction. +""" + +import atexit +import json +import logging +from typing import Any, Dict + +from linkedin_mcp_server.debug_trace import cleanup_trace_dir, get_trace_dir + +_TRACE_FILE_HANDLER: logging.Handler | None = None +_TRACE_CLEANUP_REGISTERED = False + + +class MCPJSONFormatter(logging.Formatter): + """JSON formatter for MCP server logs.""" + + def format(self, record: logging.LogRecord) -> str: + """Format log record as JSON. + + Args: + record: The log record to format + + Returns: + JSON-formatted log string + """ + log_data: Dict[str, Any] = { + "timestamp": self.formatTime(record), + "level": record.levelname, + "logger": record.name, + "message": record.getMessage(), + } + + # Add error details if present + if hasattr(record, "error_type"): + log_data["error_type"] = record.error_type + if hasattr(record, "error_details"): + log_data["error_details"] = record.error_details + + # Add exception info if present + if record.exc_info: + log_data["exception"] = self.formatException(record.exc_info) + + return json.dumps(log_data) + + +class CompactFormatter(logging.Formatter): + """Compact formatter that shortens logger names and uses shorter timestamps.""" + + def format(self, record: logging.LogRecord) -> str: + """Format log record with compact formatting. + + Args: + record: The log record to format + + Returns: + Compact-formatted log string + """ + # Create a copy of the record to avoid modifying the original + record_copy = logging.LogRecord( + name=record.name, + level=record.levelno, + pathname=record.pathname, + lineno=record.lineno, + msg=record.msg, + args=record.args, + exc_info=record.exc_info, + func=record.funcName, + ) + record_copy.stack_info = record.stack_info + + # Shorten the logger name by removing the linkedin_mcp_server prefix + if record_copy.name.startswith("linkedin_mcp_server."): + record_copy.name = record_copy.name[len("linkedin_mcp_server.") :] + + # Format the time as HH:MM:SS only + record_copy.asctime = self.formatTime(record_copy, datefmt="%H:%M:%S") + + return f"{record_copy.asctime} - {record_copy.name} - {record.levelname} - {record.getMessage()}" + + +def configure_logging(log_level: str = "WARNING", json_format: bool = False) -> None: + """Configure logging for the LinkedIn MCP Server. + + Args: + log_level: Logging level (DEBUG, INFO, WARNING, ERROR) + json_format: Whether to use JSON formatting for logs + """ + # Convert string to logging level + numeric_level = getattr(logging, log_level.upper(), logging.WARNING) + + if json_format: + formatter = MCPJSONFormatter() + else: + formatter = CompactFormatter() + + # Configure root logger + root_logger = logging.getLogger() + root_logger.setLevel(numeric_level) + + # Remove existing handlers + for handler in root_logger.handlers[:]: + root_logger.removeHandler(handler) + try: + handler.close() + except Exception: + pass + + global _TRACE_CLEANUP_REGISTERED, _TRACE_FILE_HANDLER + _TRACE_FILE_HANDLER = None + + # Add console handler + console_handler = logging.StreamHandler() + console_handler.setFormatter(formatter) + root_logger.addHandler(console_handler) + + trace_dir = get_trace_dir() + if trace_dir is not None: + trace_dir.mkdir(parents=True, exist_ok=True) + file_handler = logging.FileHandler(trace_dir / "server.log", encoding="utf-8") + file_handler.setFormatter(formatter) + root_logger.addHandler(file_handler) + _TRACE_FILE_HANDLER = file_handler + if not _TRACE_CLEANUP_REGISTERED: + # The atexit fallback intentionally delegates the keep/delete + # decision to teardown_trace_logging(), which re-checks runtime + # trace retention state via cleanup_trace_dir(). + atexit.register(teardown_trace_logging) + _TRACE_CLEANUP_REGISTERED = True + + # Set specific loggers to reduce noise + logging.getLogger("urllib3").setLevel(logging.ERROR) + logging.getLogger("urllib3.connectionpool").setLevel(logging.ERROR) + logging.getLogger("fakeredis").setLevel(logging.WARNING) + logging.getLogger("docket").setLevel(logging.WARNING) + + +def teardown_trace_logging(*, keep_traces: bool = False) -> None: + """Close trace logging handlers and cleanup ephemeral traces when allowed.""" + global _TRACE_FILE_HANDLER + + if _TRACE_FILE_HANDLER is not None: + root_logger = logging.getLogger() + root_logger.removeHandler(_TRACE_FILE_HANDLER) + try: + _TRACE_FILE_HANDLER.close() + finally: + _TRACE_FILE_HANDLER = None + + if not keep_traces: + cleanup_trace_dir() diff --git a/linkedin_mcp_server/py.typed b/linkedin_mcp_server/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/linkedin_mcp_server/scraping/__init__.py b/linkedin_mcp_server/scraping/__init__.py new file mode 100644 index 00000000..07eb584b --- /dev/null +++ b/linkedin_mcp_server/scraping/__init__.py @@ -0,0 +1,17 @@ +"""Scraping engine using innerText extraction.""" + +from .extractor import LinkedInExtractor +from .fields import ( + COMPANY_SECTIONS, + PERSON_SECTIONS, + parse_company_sections, + parse_person_sections, +) + +__all__ = [ + "COMPANY_SECTIONS", + "LinkedInExtractor", + "PERSON_SECTIONS", + "parse_company_sections", + "parse_person_sections", +] diff --git a/linkedin_mcp_server/scraping/extractor.py b/linkedin_mcp_server/scraping/extractor.py new file mode 100644 index 00000000..42c2e774 --- /dev/null +++ b/linkedin_mcp_server/scraping/extractor.py @@ -0,0 +1,1158 @@ +"""Core extraction engine using innerText instead of DOM selectors.""" + +import asyncio +from dataclasses import dataclass +import logging +import re +from typing import Any, Literal +from urllib.parse import quote_plus + +from patchright.async_api import Page, TimeoutError as PlaywrightTimeoutError + +from linkedin_mcp_server.core import ( + detect_auth_barrier, + detect_auth_barrier_quick, + resolve_remember_me_prompt, +) +from linkedin_mcp_server.core.exceptions import ( + AuthenticationError, + LinkedInScraperException, +) +from linkedin_mcp_server.debug_trace import record_page_trace +from linkedin_mcp_server.debug_utils import stabilize_navigation +from linkedin_mcp_server.error_diagnostics import build_issue_diagnostics +from linkedin_mcp_server.core.utils import ( + detect_rate_limit, + handle_modal_close, + scroll_job_sidebar, + scroll_to_bottom, +) +from linkedin_mcp_server.scraping.link_metadata import ( + Reference, + build_references, + dedupe_references, +) + +from .fields import COMPANY_SECTIONS, PERSON_SECTIONS + +logger = logging.getLogger(__name__) + +WaitUntil = Literal["commit", "domcontentloaded", "load", "networkidle"] + +# Delay between page navigations to avoid rate limiting +_NAV_DELAY = 2.0 + +# Backoff before retrying a rate-limited page +_RATE_LIMIT_RETRY_DELAY = 5.0 + +# Returned as section text when LinkedIn rate-limits the page +_RATE_LIMITED_MSG = "[Rate limited] LinkedIn blocked this section. Try again later or request fewer sections." + +# LinkedIn shows 25 results per page +_PAGE_SIZE = 25 + +# Normalization maps for job search filters +_DATE_POSTED_MAP = { + "past_hour": "r3600", + "past_24_hours": "r86400", + "past_week": "r604800", + "past_month": "r2592000", +} + +_EXPERIENCE_LEVEL_MAP = { + "internship": "1", + "entry": "2", + "associate": "3", + "mid_senior": "4", + "director": "5", + "executive": "6", +} + +_JOB_TYPE_MAP = { + "full_time": "F", + "part_time": "P", + "contract": "C", + "temporary": "T", + "volunteer": "V", + "internship": "I", + "other": "O", +} + +_WORK_TYPE_MAP = {"on_site": "1", "remote": "2", "hybrid": "3"} + +_SORT_BY_MAP = {"date": "DD", "relevance": "R"} + + +def _normalize_csv(value: str, mapping: dict[str, str]) -> str: + """Normalize a comma-separated filter value using the provided mapping.""" + parts = [v.strip() for v in value.split(",")] + return ",".join(mapping.get(p, p) for p in parts) + + +# Patterns that mark the start of LinkedIn page chrome (sidebar/footer). +# Everything from the earliest match onwards is stripped. +_NOISE_MARKERS: list[re.Pattern[str]] = [ + # Footer nav links: "About" immediately followed by "Accessibility" or "Talent Solutions" + re.compile(r"^About\n+(?:Accessibility|Talent Solutions)", re.MULTILINE), + # Sidebar profile recommendations + re.compile(r"^More profiles for you$", re.MULTILINE), + # Sidebar premium upsell + re.compile(r"^Explore premium profiles$", re.MULTILINE), + # InMail upsell in contact info overlay + re.compile(r"^Get up to .+ replies when you message with InMail$", re.MULTILINE), + # Footer nav clusters in profile/posts pages + re.compile( + r"^(?:Careers|Privacy & Terms|Questions\?|Select language)\n+" + r"(?:Privacy & Terms|Questions\?|Select language|Advertising|Ad Choices|" + r"[A-Za-z]+ \([A-Za-z]+\))", + re.MULTILINE, + ), +] + +_NOISE_LINES: list[re.Pattern[str]] = [ + re.compile(r"^(?:Play|Pause|Playback speed|Turn fullscreen on|Fullscreen)$"), + re.compile(r"^(?:Show captions|Close modal window|Media player modal window)$"), + re.compile(r"^(?:Loaded:.*|Remaining time.*|Stream Type.*)$"), +] + + +@dataclass +class ExtractedSection: + """Text and compact references extracted from a loaded LinkedIn section.""" + + text: str + references: list[Reference] + error: dict[str, Any] | None = None + + +def strip_linkedin_noise(text: str) -> str: + """Remove LinkedIn page chrome (footer, sidebar recommendations) from innerText. + + Finds the earliest occurrence of any known noise marker and truncates there. + """ + cleaned = _truncate_linkedin_noise(text) + return _filter_linkedin_noise_lines(cleaned) + + +def _filter_linkedin_noise_lines(text: str) -> str: + """Remove known media/control noise lines from already-truncated content.""" + filtered_lines = [ + line + for line in text.splitlines() + if not any(pattern.match(line.strip()) for pattern in _NOISE_LINES) + ] + return "\n".join(filtered_lines).strip() + + +def _truncate_linkedin_noise(text: str) -> str: + """Trim known LinkedIn chrome blocks before any per-line noise filtering.""" + earliest = len(text) + for pattern in _NOISE_MARKERS: + match = pattern.search(text) + if match and match.start() < earliest: + earliest = match.start() + + return text[:earliest].strip() + + +class LinkedInExtractor: + """Extracts LinkedIn page content via navigate-scroll-innerText pattern.""" + + def __init__(self, page: Page): + self._page = page + + @staticmethod + def _normalize_body_marker(value: Any) -> str: + """Compress body text into a short, single-line diagnostic marker.""" + if not isinstance(value, str): + return "" + return re.sub(r"\s+", " ", value).strip()[:200] + + async def _log_navigation_failure( + self, + target_url: str, + wait_until: str, + navigation_error: Exception, + hops: list[str], + ) -> None: + """Emit structured diagnostics for a failed target navigation.""" + try: + title = await self._page.title() + except Exception: + title = "" + + try: + auth_barrier = await detect_auth_barrier(self._page) + except Exception: + auth_barrier = None + + try: + remember_me_visible = ( + await self._page.locator("#rememberme-div").count() + ) > 0 + except Exception: + remember_me_visible = False + + try: + body_marker = self._normalize_body_marker( + await self._page.evaluate("() => document.body?.innerText || ''") + ) + except Exception: + body_marker = "" + + logger.warning( + "Navigation to %s failed (wait_until=%s, error=%s). " + "current_url=%s title=%r auth_barrier=%s remember_me=%s hops=%s body_marker=%r", + target_url, + wait_until, + navigation_error, + self._page.url, + title, + auth_barrier, + remember_me_visible, + hops, + body_marker, + ) + + async def _raise_if_auth_barrier( + self, + url: str, + *, + navigation_error: Exception | None = None, + ) -> None: + """Raise an auth error when LinkedIn shows login/account-picker UI.""" + barrier = await detect_auth_barrier(self._page) + if not barrier: + return + + logger.warning("Authentication barrier detected on %s: %s", url, barrier) + message = ( + "LinkedIn requires interactive re-authentication. " + "Run with --login and complete the account selection/sign-in flow." + ) + if navigation_error is not None: + raise AuthenticationError(message) from navigation_error + raise AuthenticationError(message) + + async def _goto_with_auth_checks( + self, + url: str, + *, + wait_until: WaitUntil = "domcontentloaded", + allow_remember_me: bool = True, + ) -> None: + """Navigate to a LinkedIn page and fail fast on auth barriers.""" + hops: list[str] = [] + listener_registered = False + + def record_navigation(frame: Any) -> None: + if frame != self._page.main_frame: + return + frame_url = getattr(frame, "url", "") + if frame_url and (not hops or hops[-1] != frame_url): + hops.append(frame_url) + + def unregister_navigation_listener() -> None: + nonlocal listener_registered + if not listener_registered: + return + self._page.remove_listener("framenavigated", record_navigation) + listener_registered = False + + self._page.on("framenavigated", record_navigation) + listener_registered = True + try: + await record_page_trace( + self._page, + "extractor-before-goto", + extra={"target_url": url, "wait_until": wait_until}, + ) + try: + await self._page.goto(url, wait_until=wait_until, timeout=30000) + await stabilize_navigation(f"goto {url}", logger) + await record_page_trace( + self._page, + "extractor-after-goto", + extra={"target_url": url, "wait_until": wait_until}, + ) + except Exception as exc: + if allow_remember_me and await resolve_remember_me_prompt(self._page): + await stabilize_navigation( + f"remember-me resolution for {url}", logger + ) + await record_page_trace( + self._page, + "extractor-navigation-error-before-remember-me-retry", + extra={ + "target_url": url, + "wait_until": wait_until, + "error": f"{type(exc).__name__}: {exc}", + "hops": hops, + }, + ) + await record_page_trace( + self._page, + "extractor-after-remember-me", + extra={ + "target_url": url, + "error": f"{type(exc).__name__}: {exc}", + }, + ) + unregister_navigation_listener() + await self._goto_with_auth_checks( + url, + wait_until=wait_until, + allow_remember_me=False, + ) + return + await record_page_trace( + self._page, + "extractor-navigation-error", + extra={ + "target_url": url, + "wait_until": wait_until, + "error": f"{type(exc).__name__}: {exc}", + "hops": hops, + }, + ) + await self._log_navigation_failure(url, wait_until, exc, hops) + await self._raise_if_auth_barrier(url, navigation_error=exc) + raise + + barrier = await detect_auth_barrier_quick(self._page) + if not barrier: + return + + if allow_remember_me and await resolve_remember_me_prompt(self._page): + await stabilize_navigation(f"remember-me retry for {url}", logger) + await record_page_trace( + self._page, + "extractor-after-remember-me-retry", + extra={"target_url": url, "barrier": barrier}, + ) + unregister_navigation_listener() + await self._goto_with_auth_checks( + url, + wait_until=wait_until, + allow_remember_me=False, + ) + return + + await record_page_trace( + self._page, + "extractor-auth-barrier", + extra={"target_url": url, "barrier": barrier}, + ) + logger.warning("Authentication barrier detected on %s: %s", url, barrier) + raise AuthenticationError( + "LinkedIn requires interactive re-authentication. " + "Run with --login and complete the account selection/sign-in flow." + ) + finally: + unregister_navigation_listener() + + async def _navigate_to_page(self, url: str) -> None: + """Navigate to a LinkedIn page and fail fast on auth barriers.""" + await self._goto_with_auth_checks(url) + + async def extract_page( + self, + url: str, + section_name: str, + ) -> ExtractedSection: + """Navigate to a URL, scroll to load lazy content, and extract innerText. + + Retries once after a backoff when the page returns only LinkedIn chrome + (sidebar/footer noise with no actual content), which indicates a soft + rate limit. + + Raises LinkedInScraperException subclasses (rate limit, auth, etc.). + Returns _RATE_LIMITED_MSG sentinel when soft-rate-limited after retry. + Returns empty string for unexpected non-domain failures (error isolation). + """ + try: + result = await self._extract_page_once(url, section_name) + if result.text != _RATE_LIMITED_MSG: + return result + + # Retry once after backoff + logger.info("Retrying %s after %.0fs backoff", url, _RATE_LIMIT_RETRY_DELAY) + await asyncio.sleep(_RATE_LIMIT_RETRY_DELAY) + return await self._extract_page_once(url, section_name) + + except LinkedInScraperException: + raise + except Exception as e: + logger.warning("Failed to extract page %s: %s", url, e) + return ExtractedSection( + text="", + references=[], + error=build_issue_diagnostics( + e, + context="extract_page", + target_url=url, + section_name=section_name, + ), + ) + + async def _extract_page_once( + self, + url: str, + section_name: str, + ) -> ExtractedSection: + """Single attempt to navigate, scroll, and extract innerText.""" + await self._navigate_to_page(url) + await detect_rate_limit(self._page) + + # Wait for main content to render + try: + await self._page.wait_for_selector("main", timeout=5000) + except PlaywrightTimeoutError: + logger.debug("No
element found on %s", url) + + # Dismiss any modals blocking content + await handle_modal_close(self._page) + + # Activity feed pages lazy-load post content after the tab header + is_activity = "/recent-activity/" in url + if is_activity: + try: + await self._page.wait_for_function( + """() => { + const main = document.querySelector('main'); + if (!main) return false; + return main.innerText.length > 200; + }""", + timeout=10000, + ) + except PlaywrightTimeoutError: + logger.debug("Activity feed content did not appear on %s", url) + + # Search results pages load a placeholder first then fill in results + # via JavaScript. Wait for actual content before extracting. + is_search = "/search/results/" in url + if is_search: + try: + await self._page.wait_for_function( + """() => { + const main = document.querySelector('main'); + if (!main) return false; + return main.innerText.length > 100; + }""", + timeout=10000, + ) + except PlaywrightTimeoutError: + logger.debug("Search results content did not appear on %s", url) + + # Scroll to trigger lazy loading + if is_activity: + await scroll_to_bottom(self._page, pause_time=1.0, max_scrolls=10) + else: + await scroll_to_bottom(self._page, pause_time=0.5, max_scrolls=5) + + # Extract text from main content area + raw_result = await self._extract_root_content(["main"]) + raw = raw_result["text"] + + if not raw: + return ExtractedSection(text="", references=[]) + truncated = _truncate_linkedin_noise(raw) + if not truncated and raw.strip(): + logger.warning( + "Page %s returned only LinkedIn chrome (likely rate-limited)", url + ) + return ExtractedSection(text=_RATE_LIMITED_MSG, references=[]) + cleaned = _filter_linkedin_noise_lines(truncated) + return ExtractedSection( + text=cleaned, + references=build_references(raw_result["references"], section_name), + ) + + async def _extract_overlay( + self, + url: str, + section_name: str, + ) -> ExtractedSection: + """Extract content from an overlay/modal page (e.g. contact info). + + LinkedIn renders contact info as a native element. + Falls back to `
` if no dialog is found. + + Retries once after a backoff when the overlay returns only LinkedIn + chrome (noise), mirroring `extract_page` behavior. + """ + try: + result = await self._extract_overlay_once(url, section_name) + if result.text != _RATE_LIMITED_MSG: + return result + + logger.info( + "Retrying overlay %s after %.0fs backoff", + url, + _RATE_LIMIT_RETRY_DELAY, + ) + await asyncio.sleep(_RATE_LIMIT_RETRY_DELAY) + return await self._extract_overlay_once(url, section_name) + + except LinkedInScraperException: + raise + except Exception as e: + logger.warning("Failed to extract overlay %s: %s", url, e) + return ExtractedSection( + text="", + references=[], + error=build_issue_diagnostics( + e, + context="extract_overlay", + target_url=url, + section_name=section_name, + ), + ) + + async def _extract_overlay_once( + self, + url: str, + section_name: str, + ) -> ExtractedSection: + """Single attempt to extract content from an overlay/modal page.""" + await self._navigate_to_page(url) + await detect_rate_limit(self._page) + + # Wait for the dialog/modal to render (LinkedIn uses native ) + try: + await self._page.wait_for_selector( + "dialog[open], .artdeco-modal__content", timeout=5000 + ) + except PlaywrightTimeoutError: + logger.debug("No modal overlay found on %s, falling back to main", url) + + # NOTE: Do NOT call handle_modal_close() here — the contact-info + # overlay *is* a dialog/modal. Dismissing it would destroy the + # content before the JS evaluation below can read it. + + raw_result = await self._extract_root_content( + ["dialog[open]", ".artdeco-modal__content", "main"], + ) + raw = raw_result["text"] + + if not raw: + return ExtractedSection(text="", references=[]) + truncated = _truncate_linkedin_noise(raw) + if not truncated and raw.strip(): + logger.warning( + "Overlay %s returned only LinkedIn chrome (likely rate-limited)", + url, + ) + return ExtractedSection(text=_RATE_LIMITED_MSG, references=[]) + cleaned = _filter_linkedin_noise_lines(truncated) + return ExtractedSection( + text=cleaned, + references=build_references(raw_result["references"], section_name), + ) + + async def scrape_person(self, username: str, requested: set[str]) -> dict[str, Any]: + """Scrape a person profile with configurable sections. + + Returns: + {url, sections: {name: text}} + """ + requested = requested | {"main_profile"} + base_url = f"https://www.linkedin.com/in/{username}" + sections: dict[str, str] = {} + references: dict[str, list[Reference]] = {} + section_errors: dict[str, dict[str, Any]] = {} + + first = True + for section_name, (suffix, is_overlay) in PERSON_SECTIONS.items(): + if section_name not in requested: + continue + + if not first: + await asyncio.sleep(_NAV_DELAY) + first = False + + url = base_url + suffix + try: + if is_overlay: + extracted = await self._extract_overlay( + url, section_name=section_name + ) + else: + extracted = await self.extract_page(url, section_name=section_name) + + if extracted.text and extracted.text != _RATE_LIMITED_MSG: + sections[section_name] = extracted.text + if extracted.references: + references[section_name] = extracted.references + elif extracted.error: + section_errors[section_name] = extracted.error + except LinkedInScraperException: + raise + except Exception as e: + logger.warning("Error scraping section %s: %s", section_name, e) + section_errors[section_name] = build_issue_diagnostics( + e, + context="scrape_person", + target_url=url, + section_name=section_name, + ) + + result: dict[str, Any] = { + "url": f"{base_url}/", + "sections": sections, + } + if references: + result["references"] = references + if section_errors: + result["section_errors"] = section_errors + return result + + async def scrape_company( + self, company_name: str, requested: set[str] + ) -> dict[str, Any]: + """Scrape a company profile with configurable sections. + + Returns: + {url, sections: {name: text}} + """ + requested = requested | {"about"} + base_url = f"https://www.linkedin.com/company/{company_name}" + sections: dict[str, str] = {} + references: dict[str, list[Reference]] = {} + section_errors: dict[str, dict[str, Any]] = {} + + first = True + for section_name, (suffix, is_overlay) in COMPANY_SECTIONS.items(): + if section_name not in requested: + continue + + if not first: + await asyncio.sleep(_NAV_DELAY) + first = False + + url = base_url + suffix + try: + if is_overlay: + extracted = await self._extract_overlay( + url, section_name=section_name + ) + else: + extracted = await self.extract_page(url, section_name=section_name) + + if extracted.text and extracted.text != _RATE_LIMITED_MSG: + sections[section_name] = extracted.text + if extracted.references: + references[section_name] = extracted.references + elif extracted.error: + section_errors[section_name] = extracted.error + except LinkedInScraperException: + raise + except Exception as e: + logger.warning("Error scraping section %s: %s", section_name, e) + section_errors[section_name] = build_issue_diagnostics( + e, + context="scrape_company", + target_url=url, + section_name=section_name, + ) + + result: dict[str, Any] = { + "url": f"{base_url}/", + "sections": sections, + } + if references: + result["references"] = references + if section_errors: + result["section_errors"] = section_errors + return result + + async def scrape_job(self, job_id: str) -> dict[str, Any]: + """Scrape a single job posting. + + Returns: + {url, sections: {name: text}} + """ + url = f"https://www.linkedin.com/jobs/view/{job_id}/" + extracted = await self.extract_page(url, section_name="job_posting") + + sections: dict[str, str] = {} + references: dict[str, list[Reference]] = {} + section_errors: dict[str, dict[str, Any]] = {} + if extracted.text and extracted.text != _RATE_LIMITED_MSG: + sections["job_posting"] = extracted.text + if extracted.references: + references["job_posting"] = extracted.references + elif extracted.error: + section_errors["job_posting"] = extracted.error + + result: dict[str, Any] = { + "url": url, + "sections": sections, + } + if references: + result["references"] = references + if section_errors: + result["section_errors"] = section_errors + return result + + async def _extract_job_ids(self) -> list[str]: + """Extract unique job IDs from job card links on the current page. + + Finds all `a[href*="/jobs/view/"]` links and extracts the numeric + job ID from each href. Returns deduplicated IDs in DOM order. + """ + return await self._page.evaluate( + """() => { + const links = document.querySelectorAll('a[href*="/jobs/view/"]'); + const seen = new Set(); + const ids = []; + for (const a of links) { + const match = a.href.match(/\\/jobs\\/view\\/(\\d+)/); + if (match && !seen.has(match[1])) { + seen.add(match[1]); + ids.push(match[1]); + } + } + return ids; + }""" + ) + + async def _extract_search_page( + self, + url: str, + section_name: str, + ) -> ExtractedSection: + """Extract innerText from a job search page with soft rate-limit retry. + + Mirrors the noise-only detection and single-retry behavior of + ``extract_page`` / ``_extract_page_once`` so that callers get a + ``_RATE_LIMITED_MSG`` sentinel instead of silent empty results. + """ + try: + result = await self._extract_search_page_once(url, section_name) + if result.text != _RATE_LIMITED_MSG: + return result + + logger.info( + "Retrying search page %s after %.0fs backoff", + url, + _RATE_LIMIT_RETRY_DELAY, + ) + await asyncio.sleep(_RATE_LIMIT_RETRY_DELAY) + result = await self._extract_search_page_once(url, section_name) + if result.text == _RATE_LIMITED_MSG: + logger.warning("Search page %s still rate-limited after retry", url) + return result + + except LinkedInScraperException: + raise + except Exception as e: + logger.warning("Failed to extract search page %s: %s", url, e) + return ExtractedSection( + text="", + references=[], + error=build_issue_diagnostics( + e, + context="extract_search_page", + target_url=url, + section_name=section_name, + ), + ) + + async def _extract_search_page_once( + self, + url: str, + section_name: str, + ) -> ExtractedSection: + """Single attempt to navigate, scroll sidebar, and extract innerText.""" + await self._navigate_to_page(url) + await detect_rate_limit(self._page) + + main_found = True + try: + await self._page.wait_for_selector("main", timeout=5000) + except PlaywrightTimeoutError: + logger.debug("No
element found on %s", url) + main_found = False + + await handle_modal_close(self._page) + if main_found: + await scroll_job_sidebar(self._page, pause_time=0.5, max_scrolls=5) + + raw_result = await self._extract_root_content(["main"]) + raw = raw_result["text"] + if raw_result["source"] == "body": + logger.debug("No
at evaluation time on %s, using body fallback", url) + elif not main_found: + logger.debug( + "
appeared after wait timeout on %s, sidebar scroll was skipped", + url, + ) + + if not raw: + return ExtractedSection(text="", references=[]) + truncated = _truncate_linkedin_noise(raw) + if not truncated and raw.strip(): + logger.warning( + "Search page %s returned only LinkedIn chrome (likely rate-limited)", + url, + ) + return ExtractedSection(text=_RATE_LIMITED_MSG, references=[]) + cleaned = _filter_linkedin_noise_lines(truncated) + return ExtractedSection( + text=cleaned, + references=build_references(raw_result["references"], section_name), + ) + + async def _get_total_search_pages(self) -> int | None: + """Read total page count from LinkedIn's pagination state element. + + Parses the "Page X of Y" text from ``.jobs-search-pagination__page-state``. + Returns ``None`` when the element is absent or unparseable. + + NOTE: This is a deliberate DOM exception. The element has ``display: none`` + (screen-reader only), so the text never appears in ``innerText``. A class-based + selector is the only reliable way to read it. Gracefully returns ``None`` if + LinkedIn renames the class — pagination just falls back to ``max_pages``. + """ + text = await self._page.evaluate( + """() => { + const el = document.querySelector( + '.jobs-search-pagination__page-state' + ); + return el ? el.textContent.trim() : null; + }""" + ) + if not text: + return None + match = re.search(r"of\s+(\d+)", text) + return int(match.group(1)) if match else None + + @staticmethod + def _build_job_search_url( + keywords: str, + location: str | None = None, + date_posted: str | None = None, + job_type: str | None = None, + experience_level: str | None = None, + work_type: str | None = None, + easy_apply: bool = False, + sort_by: str | None = None, + ) -> str: + """Build a LinkedIn job search URL with optional filters. + + Human-readable names are normalized to LinkedIn URL codes. + Comma-separated values are normalized individually. + Unknown values pass through unchanged. + """ + params = f"keywords={quote_plus(keywords)}" + if location: + params += f"&location={quote_plus(location)}" + + if date_posted: + mapped = _DATE_POSTED_MAP.get(date_posted.strip(), date_posted) + params += f"&f_TPR={quote_plus(mapped)}" + if job_type: + params += f"&f_JT={_normalize_csv(job_type, _JOB_TYPE_MAP)}" + if experience_level: + params += f"&f_E={_normalize_csv(experience_level, _EXPERIENCE_LEVEL_MAP)}" + if work_type: + params += f"&f_WT={_normalize_csv(work_type, _WORK_TYPE_MAP)}" + if easy_apply: + params += "&f_EA=true" + if sort_by: + mapped = _SORT_BY_MAP.get(sort_by.strip(), sort_by) + params += f"&sortBy={quote_plus(mapped)}" + + return f"https://www.linkedin.com/jobs/search/?{params}" + + async def search_jobs( + self, + keywords: str, + location: str | None = None, + max_pages: int = 3, + date_posted: str | None = None, + job_type: str | None = None, + experience_level: str | None = None, + work_type: str | None = None, + easy_apply: bool = False, + sort_by: str | None = None, + ) -> dict[str, Any]: + """Search for jobs with pagination and job ID extraction. + + Scrolls the job sidebar (not the main page) and paginates through + results. Uses LinkedIn's "Page X of Y" indicator to cap pagination, + and stops early when a page yields no new job IDs. + + Args: + keywords: Search keywords + location: Optional location filter + max_pages: Maximum pages to load (1-10, default 3) + date_posted: Filter by date posted (past_hour, past_24_hours, past_week, past_month) + job_type: Filter by job type (full_time, part_time, contract, temporary, volunteer, internship, other) + experience_level: Filter by experience level (internship, entry, associate, mid_senior, director, executive) + work_type: Filter by work type (on_site, remote, hybrid) + easy_apply: Only show Easy Apply jobs + sort_by: Sort results (date, relevance) + + Returns: + {url, sections: {search_results: text}, job_ids: [str]} + """ + base_url = self._build_job_search_url( + keywords, + location=location, + date_posted=date_posted, + job_type=job_type, + experience_level=experience_level, + work_type=work_type, + easy_apply=easy_apply, + sort_by=sort_by, + ) + all_job_ids: list[str] = [] + seen_ids: set[str] = set() + page_texts: list[str] = [] + page_references: list[Reference] = [] + section_errors: dict[str, dict[str, Any]] = {} + total_pages: int | None = None + total_pages_queried = False + + for page_num in range(max_pages): + # Stop if we already know we've reached the last page + if total_pages is not None and page_num >= total_pages: + logger.debug("All %d pages fetched, stopping", total_pages) + break + + if page_num > 0: + await asyncio.sleep(_NAV_DELAY) + + url = ( + base_url + if page_num == 0 + else f"{base_url}&start={page_num * _PAGE_SIZE}" + ) + + try: + extracted = await self._extract_search_page( + url, section_name="search_results" + ) + + if not extracted.text or extracted.text == _RATE_LIMITED_MSG: + if extracted.error: + section_errors["search_results"] = extracted.error + # Navigation failed or rate-limited; skip ID extraction + break + + # Read total pages from pagination state (once only, best-effort) + if not total_pages_queried: + total_pages_queried = True + try: + total_pages = await self._get_total_search_pages() + except Exception as e: + logger.debug("Could not read total pages: %s", e) + else: + if total_pages is not None: + logger.debug("LinkedIn reports %d total pages", total_pages) + + # Extract job IDs from hrefs (page is already loaded) + if not self._page.url.startswith( + "https://www.linkedin.com/jobs/search/" + ): + logger.debug( + "Unexpected page URL after extraction: %s — " + "skipping job ID extraction", + self._page.url, + ) + page_texts.append(extracted.text) + if extracted.references: + page_references.extend(extracted.references) + break + page_ids = await self._extract_job_ids() + new_ids = [jid for jid in page_ids if jid not in seen_ids] + + if not new_ids: + page_texts.append(extracted.text) + if extracted.references: + page_references.extend(extracted.references) + logger.debug("No new job IDs on page %d, stopping", page_num + 1) + break + + for jid in new_ids: + seen_ids.add(jid) + all_job_ids.append(jid) + + page_texts.append(extracted.text) + if extracted.references: + page_references.extend(extracted.references) + + except LinkedInScraperException: + raise + except Exception as e: + logger.warning("Error on search page %d: %s", page_num + 1, e) + section_errors["search_results"] = build_issue_diagnostics( + e, + context="search_jobs", + target_url=url, + section_name="search_results", + ) + break + + result: dict[str, Any] = { + "url": base_url, + "sections": {"search_results": "\n---\n".join(page_texts)} + if page_texts + else {}, + "job_ids": all_job_ids, + } + if page_references: + result["references"] = { + "search_results": dedupe_references(page_references, cap=15) + } + if section_errors: + result["section_errors"] = section_errors + return result + + async def search_people( + self, + keywords: str, + location: str | None = None, + ) -> dict[str, Any]: + """Search for people and extract the results page. + + Returns: + {url, sections: {name: text}} + """ + params = f"keywords={quote_plus(keywords)}" + if location: + params += f"&location={quote_plus(location)}" + + url = f"https://www.linkedin.com/search/results/people/?{params}" + extracted = await self.extract_page(url, section_name="search_results") + + sections: dict[str, str] = {} + references: dict[str, list[Reference]] = {} + section_errors: dict[str, dict[str, Any]] = {} + if extracted.text and extracted.text != _RATE_LIMITED_MSG: + sections["search_results"] = extracted.text + if extracted.references: + references["search_results"] = extracted.references + elif extracted.error: + section_errors["search_results"] = extracted.error + + result: dict[str, Any] = { + "url": url, + "sections": sections, + } + if references: + result["references"] = references + if section_errors: + result["section_errors"] = section_errors + return result + + async def _extract_root_content( + self, + selectors: list[str], + ) -> dict[str, Any]: + """Extract innerText and raw anchor metadata from the first matching root.""" + result = await self._page.evaluate( + """({ selectors }) => { + const normalize = value => (value || '').replace(/\\s+/g, ' ').trim(); + const containerSelector = 'section, article, li, div'; + const headingSelector = 'h1, h2, h3'; + const directHeadingSelector = ':scope > h1, :scope > h2, :scope > h3'; + const MAX_HEADING_CONTAINERS = 300; + const MAX_REFERENCE_ANCHORS = 500; + + const getHeadingText = element => { + if (!element) return ''; + + const heading = + element.matches && element.matches(headingSelector) + ? element + : element.querySelector + ? element.querySelector(directHeadingSelector) + : null; + + return normalize(heading?.innerText || heading?.textContent); + }; + + const getPreviousHeading = node => { + let sibling = node?.previousElementSibling || null; + for (let index = 0; sibling && index < 3; index += 1) { + const heading = getHeadingText(sibling); + if (heading) { + return heading; + } + sibling = sibling.previousElementSibling; + } + return ''; + }; + + const root = selectors + .map(selector => document.querySelector(selector)) + .find(Boolean); + const source = root ? 'root' : 'body'; + const container = root || document.body; + const text = container ? (container.innerText || '').trim() : ''; + const headingMap = new WeakMap(); + + const candidateContainers = [ + container, + ...Array.from(container.querySelectorAll(containerSelector)).slice( + 0, + MAX_HEADING_CONTAINERS, + ), + ]; + candidateContainers.forEach(node => { + const ownHeading = getHeadingText(node); + const previousHeading = getPreviousHeading(node); + const heading = ownHeading || previousHeading; + if (heading) { + headingMap.set(node, heading); + } + }); + + const findHeading = element => { + let current = element.closest(containerSelector) || container; + for (let depth = 0; current && depth < 4; depth += 1) { + const heading = headingMap.get(current); + if (heading) { + return heading; + } + if (current === container) { + break; + } + current = current.parentElement?.closest(containerSelector) || null; + } + return ''; + }; + + const references = Array.from(container.querySelectorAll('a[href]')) + .slice(0, MAX_REFERENCE_ANCHORS) + .map(anchor => { + const rawHref = (anchor.getAttribute('href') || '').trim(); + if (!rawHref || rawHref === '#') { + return null; + } + + const href = rawHref.startsWith('#') + ? rawHref + : (anchor.href || rawHref); + + return { + href, + text: normalize(anchor.innerText || anchor.textContent), + aria_label: normalize(anchor.getAttribute('aria-label')), + title: normalize(anchor.getAttribute('title')), + heading: findHeading(anchor), + in_article: Boolean(anchor.closest('article')), + in_nav: Boolean(anchor.closest('nav')), + in_footer: Boolean(anchor.closest('footer')), + }; + }) + .filter(Boolean); + + return { source, text, references }; + }""", + {"selectors": selectors}, + ) + return result diff --git a/linkedin_mcp_server/scraping/fields.py b/linkedin_mcp_server/scraping/fields.py new file mode 100644 index 00000000..a0c986eb --- /dev/null +++ b/linkedin_mcp_server/scraping/fields.py @@ -0,0 +1,85 @@ +"""Section config dicts controlling which LinkedIn pages are visited during scraping.""" + +import logging + +logger = logging.getLogger(__name__) + +# Maps section name -> (url_suffix, is_overlay) +PERSON_SECTIONS: dict[str, tuple[str, bool]] = { + "main_profile": ("/", False), + "experience": ("/details/experience/", False), + "education": ("/details/education/", False), + "interests": ("/details/interests/", False), + "honors": ("/details/honors/", False), + "languages": ("/details/languages/", False), + "contact_info": ("/overlay/contact-info/", True), + "posts": ("/recent-activity/all/", False), +} + +COMPANY_SECTIONS: dict[str, tuple[str, bool]] = { + "about": ("/about/", False), + "posts": ("/posts/", False), + "jobs": ("/jobs/", False), +} + + +def parse_person_sections( + sections: str | None, +) -> tuple[set[str], list[str]]: + """Parse comma-separated section names into a set of requested sections. + + "main_profile" is always included. Empty/None returns {"main_profile"} only. + Unknown section names are logged as warnings and returned. + + Returns: + Tuple of (requested_sections, unknown_section_names). + """ + requested: set[str] = {"main_profile"} + unknown: list[str] = [] + if not sections: + return requested, unknown + for name in sections.split(","): + name = name.strip().lower() + if not name: + continue + if name in PERSON_SECTIONS: + requested.add(name) + else: + unknown.append(name) + logger.warning( + "Unknown person section %r ignored. Valid: %s", + name, + ", ".join(sorted(PERSON_SECTIONS)), + ) + return requested, unknown + + +def parse_company_sections( + sections: str | None, +) -> tuple[set[str], list[str]]: + """Parse comma-separated section names into a set of requested sections. + + "about" is always included. Empty/None returns {"about"} only. + Unknown section names are logged as warnings and returned. + + Returns: + Tuple of (requested_sections, unknown_section_names). + """ + requested: set[str] = {"about"} + unknown: list[str] = [] + if not sections: + return requested, unknown + for name in sections.split(","): + name = name.strip().lower() + if not name: + continue + if name in COMPANY_SECTIONS: + requested.add(name) + else: + unknown.append(name) + logger.warning( + "Unknown company section %r ignored. Valid: %s", + name, + ", ".join(sorted(COMPANY_SECTIONS)), + ) + return requested, unknown diff --git a/linkedin_mcp_server/scraping/link_metadata.py b/linkedin_mcp_server/scraping/link_metadata.py new file mode 100644 index 00000000..d6029fec --- /dev/null +++ b/linkedin_mcp_server/scraping/link_metadata.py @@ -0,0 +1,421 @@ +"""Helpers for extracting compact, typed references from LinkedIn DOM links.""" + +from __future__ import annotations + +import re +from typing import Literal, NotRequired, Required, TypedDict +from urllib.parse import parse_qs, unquote, urlparse, urlunparse + +ReferenceKind = Literal[ + "person", + "company", + "job", + "feed_post", + "article", + "newsletter", + "school", + "external", +] + + +class Reference(TypedDict): + """Compact reference payload returned to MCP clients.""" + + kind: Required[ReferenceKind] + url: Required[str] + text: NotRequired[str] + context: NotRequired[str] + + +class RawReference(TypedDict, total=False): + """Raw anchor data collected from the browser DOM.""" + + href: str + text: str + aria_label: str + title: str + heading: str + in_article: bool + in_nav: bool + in_footer: bool + + +_GENERIC_LABELS = { + "show all", + "follow", + "following", + "connect", + "send", + "like", + "comment", + "repost", + "post", + "play", + "pause", + "fullscreen", + "close", + "manage notifications", + "view my newsletter", + "my newsletter", +} + +_CONTEXT_LABELS = { + "about", + "experience", + "education", + "interests", + "honors", + "languages", + "featured", + "contact info", +} + +_SECTION_CONTEXTS = { + "experience": "experience", + "education": "education", + "interests": "interests", + "honors": "honors", + "languages": "languages", + "contact_info": "contact info", + "job_posting": "job posting", +} + +_DEFAULT_REFERENCE_CAP = 12 +_REFERENCE_CAPS = { + "main_profile": 12, + "about": 12, + "experience": 12, + "education": 12, + "interests": 12, + "honors": 12, + "languages": 12, + "posts": 12, + "jobs": 8, + "search_results": 15, + "job_posting": 8, + "contact_info": 8, +} + +_URL_LIKE_RE = re.compile(r"^(?:https?://|/)\S+$", re.IGNORECASE) +_DUPLICATE_HALVES_RE = re.compile(r"^(?P.+?)\s+(?P=value)$") +_WHITESPACE_RE = re.compile(r"\s+") +_CONNECTIONS_FOLLOW_RE = re.compile(r"\bconnections follow this page\b", re.IGNORECASE) +_COMPANY_PATH_RE = re.compile(r"^/company/([^/?#]+)") +_PERSON_PATH_RE = re.compile(r"^/in/([^/?#]+)") +_SCHOOL_PATH_RE = re.compile(r"^/school/([^/?#]+)") +_JOB_PATH_RE = re.compile(r"^/jobs/view/(\d+)") +_NEWSLETTER_PATH_RE = re.compile(r"^/newsletters/([^/?#]+)") +_PULSE_PATH_RE = re.compile(r"^/pulse/([^/?#]+)") +_FEED_PATH_RE = re.compile(r"^/feed/update/([^/?#]+)") +_MAX_REDIRECT_UNWRAP_DEPTH = 5 + + +def build_references( + raw_references: list[RawReference], + section_name: str, +) -> list[Reference]: + """Filter and normalize raw DOM anchors into compact references.""" + cap = _REFERENCE_CAPS.get(section_name, _DEFAULT_REFERENCE_CAP) + normalized_references: list[Reference] = [] + + for raw in raw_references: + normalized = normalize_reference(raw, section_name) + if normalized is None: + continue + normalized_references.append(normalized) + + return dedupe_references(normalized_references, cap=cap) + + +def normalize_reference( + raw: RawReference, + section_name: str, +) -> Reference | None: + """Normalize one raw DOM anchor into a compact reference.""" + if raw.get("in_nav") or raw.get("in_footer"): + return None + + href = normalize_url(raw.get("href", "")) + if href is None: + return None + + kind_url = classify_link(href) + if kind_url is None: + return None + kind, normalized_url = kind_url + + text = choose_reference_text(raw, kind) + if text is None and kind not in {"feed_post", "external"}: + return None + + context = derive_context(section_name, raw, kind) + + reference: Reference = { + "kind": kind, + "url": normalized_url, + } + if text: + reference["text"] = text + if context: + reference["context"] = context + return reference + + +def normalize_url(href: str, _depth: int = 0) -> str | None: + """Normalize a raw href and unwrap LinkedIn redirect URLs.""" + if _depth > _MAX_REDIRECT_UNWRAP_DEPTH: + return None + + href = href.strip() + if not href or href.startswith("#"): + return None + + parsed = urlparse(href) + scheme = parsed.scheme.lower() + if scheme in {"blob", "javascript", "mailto", "tel"}: + return None + if scheme and scheme not in {"http", "https"}: + return None + + host = parsed.netloc.lower() + if _is_linkedin_host(host) and parsed.path == "/redir/redirect/": + target = unquote((parse_qs(parsed.query).get("url") or [""])[0]).strip() + if not target: + return None + return normalize_url(target, _depth + 1) + + if not parsed.scheme: + return None + + return urlunparse((parsed.scheme, parsed.netloc, parsed.path, "", parsed.query, "")) + + +def classify_link(href: str) -> tuple[ReferenceKind, str] | None: + """Classify and canonicalize one normalized URL.""" + parsed = urlparse(href) + host = parsed.netloc.lower() + path = parsed.path or "/" + + if not _is_linkedin_host(host): + return "external", urlunparse( + (parsed.scheme, parsed.netloc, parsed.path or "/", "", "", "") + ) + + if _is_linkedin_chrome(path): + return None + + if match := _PERSON_PATH_RE.match(path): + person_suffix = path[match.end() :].lstrip("/") + first_suffix_segment = person_suffix.split("/", 1)[0] if person_suffix else "" + if first_suffix_segment in {"overlay", "details", "recent-activity"}: + return None + return "person", f"/in/{match.group(1)}/" + + if match := _COMPANY_PATH_RE.match(path): + return "company", f"/company/{match.group(1)}/" + + if match := _SCHOOL_PATH_RE.match(path): + return "school", f"/school/{match.group(1)}/" + + if match := _JOB_PATH_RE.match(path): + return "job", f"/jobs/view/{match.group(1)}/" + + if match := _NEWSLETTER_PATH_RE.match(path): + return "newsletter", f"/newsletters/{match.group(1)}/" + + if match := _PULSE_PATH_RE.match(path): + return "article", f"/pulse/{match.group(1)}/" + + if match := _FEED_PATH_RE.match(path): + return "feed_post", f"/feed/update/{match.group(1)}/" + + return None + + +def choose_reference_text( + raw: RawReference, + kind: ReferenceKind, +) -> str | None: + """Choose the best compact human-readable label for a reference.""" + candidates: list[tuple[int, str]] = [] + for priority, candidate in enumerate( + ( + raw.get("text", ""), + raw.get("aria_label", ""), + raw.get("title", ""), + ) + ): + cleaned = clean_label(candidate, kind) + if cleaned: + candidates.append((priority, cleaned)) + + if not candidates: + return None + + candidates.sort(key=lambda item: (_label_sort_key(item[1]), item[0])) + return candidates[0][1] + + +def clean_label(value: str, kind: ReferenceKind) -> str | None: + """Normalize and compact a candidate label.""" + value = _WHITESPACE_RE.sub(" ", value).strip() + if not value: + return None + + value = re.sub( + r"^(?:View:\s*|View\b\s+|Open article:\s*)", + "", + value, + flags=re.IGNORECASE, + ) + value = re.sub(r"[’']s\s+graphic link$", "", value, flags=re.IGNORECASE) + value = re.sub(r"\s+graphic link$", "", value, flags=re.IGNORECASE) + value = value.strip(" :-") + + if " by " in value and kind in {"article", "external"}: + value = value.split(" by ", 1)[0].strip() + + for separator in (" â€ĸ ", " ¡ ", " | "): + if separator in value: + value = value.split(separator, 1)[0].strip() + + duplicate_match = _DUPLICATE_HALVES_RE.match(value) + if duplicate_match: + value = duplicate_match.group("value").strip() + + if _URL_LIKE_RE.match(value): + return None + if _CONNECTIONS_FOLLOW_RE.search(value): + return None + if value.lower() in _GENERIC_LABELS: + return None + if len(value) < 2: + return None + if len(value) > 80: + return None + if not re.search(r"[A-Za-z0-9]", value): + return None + + return value + + +def derive_context( + section_name: str, + raw: RawReference, + kind: ReferenceKind, +) -> str | None: + """Build a compact context hint for one retained reference.""" + if section_name in _SECTION_CONTEXTS: + return _SECTION_CONTEXTS[section_name] + + heading = clean_heading(raw.get("heading", "")) + + if section_name == "search_results": + return "job result" if kind == "job" else "search result" + + if section_name == "posts": + if kind == "person": + return "post author" + if kind == "feed_post": + return "company post" + return "post attachment" + + if section_name in {"main_profile", "about"}: + if heading in _CONTEXT_LABELS: + return heading + if raw.get("in_article"): + return "featured" + return "top card" + + return heading if heading in _CONTEXT_LABELS else None + + +def clean_heading(value: str) -> str | None: + """Normalize a raw heading into a short supported context label.""" + value = _WHITESPACE_RE.sub(" ", value).strip().lower() + if not value: + return None + return value if value in _CONTEXT_LABELS else None + + +def _choose_better_reference(existing: Reference, new: Reference) -> Reference: + """Keep the cleaner, richer of two duplicate-url references.""" + existing_score = _reference_score(existing) + new_score = _reference_score(new) + return new if new_score > existing_score else existing + + +def dedupe_references( + references: list[Reference], + cap: int | None = None, +) -> list[Reference]: + """Dedupe references by URL while keeping the cleaner duplicate in order.""" + deduped: dict[str, Reference] = {} + ordered_urls: list[str] = [] + + for reference in references: + url = reference["url"] + existing = deduped.get(url) + if existing is None: + deduped[url] = reference + ordered_urls.append(url) + continue + deduped[url] = _choose_better_reference(existing, reference) + + ordered = [deduped[url] for url in ordered_urls] + return ordered[:cap] if cap is not None else ordered + + +def _reference_score(reference: Reference) -> tuple[int, int, int | float]: + text = reference.get("text") + context = reference.get("context") + return ( + 1 if text else 0, + 1 if context else 0, + _text_score(text), + ) + + +def _label_sort_key(label: str) -> tuple[int, int]: + """Prefer concise labels, but deprioritize short 2-character strings.""" + return (1 if len(label) < 3 else 0, len(label)) + + +def _text_score(text: str | None) -> int | float: + """Prefer richer labels while scoring missing text as strictly worst.""" + return len(text) if text else float("-inf") + + +def _is_linkedin_chrome(path: str) -> bool: + path = path.split("?", 1)[0].split("#", 1)[0] + if not path.startswith("/"): + path = f"/{path}" + + segments = [segment for segment in path.split("/") if segment] + if not segments: + return False + + first = segments[0] + second = segments[1] if len(segments) > 1 else "" + + if first in { + "help", + "legal", + "about", + "accessibility", + "mypreferences", + "preferences", + }: + return True + if first == "search" and second == "results": + return True + if first == "overlay" and second in { + "background-photo", + "browsemap-recommendations", + }: + return True + return first == "preload" and second == "custom-invite" + + +def _is_linkedin_host(host: str) -> bool: + return host == "linkedin.com" or host.endswith(".linkedin.com") diff --git a/linkedin_mcp_server/sequential_tool_middleware.py b/linkedin_mcp_server/sequential_tool_middleware.py new file mode 100644 index 00000000..d9b11c1e --- /dev/null +++ b/linkedin_mcp_server/sequential_tool_middleware.py @@ -0,0 +1,72 @@ +"""Middleware that serializes MCP tool execution within one server process.""" + +from __future__ import annotations + +import asyncio +import logging +import time + +import mcp.types as mt + +from fastmcp.server.middleware import CallNext, Middleware, MiddlewareContext +from fastmcp.tools.tool import ToolResult + +logger = logging.getLogger(__name__) + + +class SequentialToolExecutionMiddleware(Middleware): + """Ensure only one MCP tool call executes at a time per server process.""" + + def __init__(self) -> None: + self._lock = asyncio.Lock() + + async def _report_progress( + self, + context: MiddlewareContext[mt.CallToolRequestParams], + *, + message: str, + ) -> None: + fastmcp_context = context.fastmcp_context + if fastmcp_context is None or fastmcp_context.request_context is None: + return + + await fastmcp_context.report_progress( + progress=0, + total=100, + message=message, + ) + + async def on_call_tool( + self, + context: MiddlewareContext[mt.CallToolRequestParams], + call_next: CallNext[mt.CallToolRequestParams, ToolResult], + ) -> ToolResult: + tool_name = context.message.name + wait_started = time.perf_counter() + logger.debug("Waiting for scraper lock for tool '%s'", tool_name) + await self._report_progress( + context, + message="Queued waiting for scraper lock", + ) + + async with self._lock: + wait_seconds = time.perf_counter() - wait_started + logger.debug( + "Acquired scraper lock for tool '%s' after %.3fs", + tool_name, + wait_seconds, + ) + await self._report_progress( + context, + message="Scraper lock acquired, starting tool", + ) + hold_started = time.perf_counter() + try: + return await call_next(context) + finally: + hold_seconds = time.perf_counter() - hold_started + logger.debug( + "Released scraper lock for tool '%s' after %.3fs", + tool_name, + hold_seconds, + ) diff --git a/linkedin_mcp_server/server.py b/linkedin_mcp_server/server.py new file mode 100644 index 00000000..ff66b8c8 --- /dev/null +++ b/linkedin_mcp_server/server.py @@ -0,0 +1,100 @@ +""" +FastMCP server implementation for LinkedIn integration with tool registration. + +Creates and configures the MCP server with comprehensive LinkedIn tool suite including +person profiles, company data, job information, and session management capabilities. +""" + +from __future__ import annotations + +import logging +from typing import TYPE_CHECKING, Any, AsyncIterator + +from fastmcp import FastMCP + +if TYPE_CHECKING: + from linkedin_mcp_server.config.schema import OAuthConfig +from fastmcp.server.lifespan import lifespan + +from linkedin_mcp_server.constants import TOOL_TIMEOUT_SECONDS +from linkedin_mcp_server.authentication import get_authentication_source +from linkedin_mcp_server.drivers.browser import close_browser +from linkedin_mcp_server.error_handler import raise_tool_error +from linkedin_mcp_server.sequential_tool_middleware import ( + SequentialToolExecutionMiddleware, +) +from linkedin_mcp_server.tools.company import register_company_tools +from linkedin_mcp_server.tools.job import register_job_tools +from linkedin_mcp_server.tools.person import register_person_tools + +logger = logging.getLogger(__name__) + + +@lifespan +async def browser_lifespan(app: FastMCP) -> AsyncIterator[dict[str, Any]]: + """Manage browser lifecycle — cleanup on shutdown. + + Derived runtime durability must not depend on this hook. Docker runtime + sessions are checkpoint-committed when they are created. + """ + logger.info("LinkedIn MCP Server starting...") + yield {} + logger.info("LinkedIn MCP Server shutting down...") + await close_browser() + + +@lifespan +async def auth_lifespan(app: FastMCP) -> AsyncIterator[dict[str, Any]]: + """Validate authentication profile exists at startup.""" + logger.info("Validating LinkedIn authentication...") + get_authentication_source() + yield {} + + +def create_mcp_server(oauth_config: "OAuthConfig | None" = None) -> FastMCP: + """Create and configure the MCP server with all LinkedIn tools.""" + auth = None + if oauth_config and oauth_config.enabled: + from linkedin_mcp_server.auth import PasswordOAuthProvider + + if oauth_config.base_url is None: + raise ValueError("oauth_config.base_url must be set when OAuth is enabled") + if oauth_config.password is None: + raise ValueError("oauth_config.password must be set when OAuth is enabled") + auth = PasswordOAuthProvider( + base_url=oauth_config.base_url, + password=oauth_config.password, + ) + + mcp = FastMCP( + "linkedin_scraper", + lifespan=auth_lifespan | browser_lifespan, + mask_error_details=True, + auth=auth, + ) + mcp.add_middleware(SequentialToolExecutionMiddleware()) + + # Register all tools + register_person_tools(mcp) + register_company_tools(mcp) + register_job_tools(mcp) + + # Register session management tool + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Close Session", + annotations={"destructiveHint": True}, + tags={"session"}, + ) + async def close_session() -> dict[str, Any]: + """Close the current browser session and clean up resources.""" + try: + await close_browser() + return { + "status": "success", + "message": "Successfully closed the browser session and cleaned up resources", + } + except Exception as e: + raise_tool_error(e, "close_session") # NoReturn + + return mcp diff --git a/linkedin_mcp_server/session_state.py b/linkedin_mcp_server/session_state.py new file mode 100644 index 00000000..a6e590a6 --- /dev/null +++ b/linkedin_mcp_server/session_state.py @@ -0,0 +1,331 @@ +"""Runtime-aware authentication state for cross-platform profile reuse.""" + +from __future__ import annotations + +from dataclasses import asdict, dataclass, fields +import json +import logging +import platform +from pathlib import Path +import shutil +from typing import Any +from uuid import uuid4 + +from linkedin_mcp_server.common_utils import utcnow_iso +from linkedin_mcp_server.config import get_config + +logger = logging.getLogger(__name__) + +_SOURCE_STATE_FILE = "source-state.json" +_RUNTIME_STATE_FILE = "runtime-state.json" +_RUNTIME_PROFILES_DIR = "runtime-profiles" + + +@dataclass +class SourceState: + version: int + source_runtime_id: str + login_generation: str + created_at: str + profile_path: str + cookies_path: str + + +@dataclass +class RuntimeState: + version: int + runtime_id: str + source_runtime_id: str + source_login_generation: str + created_at: str + committed_at: str + profile_path: str + storage_state_path: str + commit_method: str + + +_SOURCE_STATE_FIELDS = frozenset(field.name for field in fields(SourceState)) +_RUNTIME_STATE_FIELDS = frozenset(field.name for field in fields(RuntimeState)) + + +def get_source_profile_dir() -> Path: + """Return the configured source profile directory.""" + return Path(get_config().browser.user_data_dir).expanduser() + + +def auth_root_dir(source_profile_dir: Path | None = None) -> Path: + """Return the root directory containing auth artifacts.""" + profile_dir = source_profile_dir or get_source_profile_dir() + return profile_dir.expanduser().resolve().parent + + +def portable_cookie_path(source_profile_dir: Path | None = None) -> Path: + """Return the portable cookie export path.""" + return auth_root_dir(source_profile_dir) / "cookies.json" + + +def source_state_path(source_profile_dir: Path | None = None) -> Path: + """Return the source session metadata path.""" + return auth_root_dir(source_profile_dir) / _SOURCE_STATE_FILE + + +def runtime_profiles_root(source_profile_dir: Path | None = None) -> Path: + """Return the root directory for derived runtime profiles.""" + return auth_root_dir(source_profile_dir) / _RUNTIME_PROFILES_DIR + + +def runtime_dir(runtime_id: str, source_profile_dir: Path | None = None) -> Path: + """Return the directory for one runtime's derived session.""" + return runtime_profiles_root(source_profile_dir) / runtime_id + + +def runtime_profile_dir( + runtime_id: str, source_profile_dir: Path | None = None +) -> Path: + """Return the profile directory for one runtime's derived session.""" + return runtime_dir(runtime_id, source_profile_dir) / "profile" + + +def runtime_state_path(runtime_id: str, source_profile_dir: Path | None = None) -> Path: + """Return the metadata path for one runtime's derived session.""" + return runtime_dir(runtime_id, source_profile_dir) / _RUNTIME_STATE_FILE + + +def runtime_storage_state_path( + runtime_id: str, source_profile_dir: Path | None = None +) -> Path: + """Return the storage-state snapshot path for one runtime's derived session.""" + return runtime_dir(runtime_id, source_profile_dir) / "storage-state.json" + + +def profile_exists(profile_dir: Path | None = None) -> bool: + """Check if a browser profile directory exists and is non-empty.""" + profile_dir = (profile_dir or get_source_profile_dir()).expanduser() + return profile_dir.is_dir() and any(profile_dir.iterdir()) + + +def get_runtime_id() -> str: + """Return a deterministic identity for the current browser runtime.""" + os_name = _normalize_os(platform.system()) + arch = _normalize_arch(platform.machine()) + runtime_kind = "container" if _is_container_runtime() else "host" + return f"{os_name}-{arch}-{runtime_kind}" + + +def _normalize_os(system: str) -> str: + mapping = { + "Darwin": "macos", + "Linux": "linux", + "Windows": "windows", + } + return mapping.get(system, system.lower() or "unknown") + + +def _normalize_arch(machine: str) -> str: + value = machine.lower() + if value in {"x86_64", "amd64"}: + return "amd64" + if value in {"arm64", "aarch64"}: + return "arm64" + return value or "unknown" + + +def _is_container_runtime() -> bool: + if any( + path.exists() + for path in ( + Path("/.dockerenv"), + Path("/run/.containerenv"), + Path("/run/containerenv"), + ) + ): + return True + + markers = ("docker", "containerd", "kubepods", "podman", "libpod") + for probe in ( + Path("/proc/1/cgroup"), + Path("/proc/self/cgroup"), + ): + if _path_contains_markers(probe, markers): + return True + + for probe in ( + Path("/proc/1/mountinfo"), + Path("/proc/self/mountinfo"), + ): + if _path_contains_markers(probe, markers) or _root_mount_uses_overlay(probe): + return True + + return False + + +def _path_contains_markers(path: Path, markers: tuple[str, ...]) -> bool: + if not path.exists(): + return False + + try: + text = path.read_text(encoding="utf-8", errors="ignore").lower() + except OSError: + return False + + return any(marker in text for marker in markers) + + +def _root_mount_uses_overlay(path: Path) -> bool: + if not path.exists(): + return False + + try: + lines = path.read_text(encoding="utf-8", errors="ignore").splitlines() + except OSError: + return False + + for line in lines: + if " - " not in line: + continue + left, right = line.split(" - ", maxsplit=1) + left_fields = left.split() + right_fields = right.split() + if len(left_fields) < 5 or not right_fields: + continue + if left_fields[4] == "/" and right_fields[0] == "overlay": + return True + + return False + + +def load_source_state(source_profile_dir: Path | None = None) -> SourceState | None: + """Load the source session metadata if present.""" + data = _load_json(source_state_path(source_profile_dir)) + if not data: + return None + try: + return SourceState( + **{key: value for key, value in data.items() if key in _SOURCE_STATE_FIELDS} + ) + except TypeError: + logger.warning("Ignoring invalid source-state.json") + return None + + +def write_source_state(source_profile_dir: Path | None = None) -> SourceState: + """Write a fresh source session generation after successful login.""" + profile_dir = ( + (source_profile_dir or get_source_profile_dir()).expanduser().resolve() + ) + state = SourceState( + version=1, + source_runtime_id=get_runtime_id(), + login_generation=str(uuid4()), + created_at=utcnow_iso(), + profile_path=str(profile_dir), + cookies_path=str(portable_cookie_path(profile_dir)), + ) + _write_json(source_state_path(profile_dir), asdict(state)) + return state + + +def load_runtime_state( + runtime_id: str, source_profile_dir: Path | None = None +) -> RuntimeState | None: + """Load one derived runtime's metadata if present.""" + data = _load_json(runtime_state_path(runtime_id, source_profile_dir)) + if not data: + return None + try: + return RuntimeState( + **{ + key: value + for key, value in data.items() + if key in _RUNTIME_STATE_FIELDS + } + ) + except TypeError: + logger.warning("Ignoring invalid runtime-state.json for %s", runtime_id) + return None + + +def write_runtime_state( + runtime_id: str, + source_state: SourceState, + storage_state_path: Path, + source_profile_dir: Path | None = None, + *, + created_at: str | None = None, + commit_method: str = "checkpoint_restart", +) -> RuntimeState: + """Write metadata for a derived runtime session.""" + profile_dir = runtime_profile_dir(runtime_id, source_profile_dir).resolve() + committed_at = utcnow_iso() + state = RuntimeState( + version=1, + runtime_id=runtime_id, + source_runtime_id=source_state.source_runtime_id, + source_login_generation=source_state.login_generation, + created_at=created_at or committed_at, + committed_at=committed_at, + profile_path=str(profile_dir), + storage_state_path=str(storage_state_path.resolve()), + commit_method=commit_method, + ) + _write_json(runtime_state_path(runtime_id, source_profile_dir), asdict(state)) + return state + + +def clear_runtime_profile( + runtime_id: str, source_profile_dir: Path | None = None +) -> bool: + """Remove one derived runtime profile and its metadata.""" + target = runtime_dir(runtime_id, source_profile_dir) + if not target.exists(): + return True + try: + shutil.rmtree(target) + return True + except OSError as exc: + logger.warning("Could not clear runtime profile %s: %s", target, exc) + return False + + +def clear_auth_state(source_profile_dir: Path | None = None) -> bool: + """Remove source auth artifacts and all derived runtime profiles.""" + profile_dir = (source_profile_dir or get_source_profile_dir()).expanduser() + targets = [ + profile_dir, + portable_cookie_path(profile_dir), + source_state_path(profile_dir), + runtime_profiles_root(profile_dir), + ] + + success = True + for target in targets: + if not target.exists(): + continue + try: + if target.is_dir(): + shutil.rmtree(target) + else: + target.unlink() + except OSError as exc: + logger.warning("Could not clear auth artifact %s: %s", target, exc) + success = False + return success + + +def _load_json(path: Path) -> dict[str, Any] | None: + if not path.exists(): + return None + try: + data = json.loads(path.read_text()) + except (OSError, json.JSONDecodeError): + logger.warning("Ignoring unreadable auth state file: %s", path) + return None + if not isinstance(data, dict): + logger.warning("Ignoring malformed auth state file: %s", path) + return None + return data + + +def _write_json(path: Path, payload: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n") diff --git a/linkedin_mcp_server/setup.py b/linkedin_mcp_server/setup.py new file mode 100644 index 00000000..49f2bcc8 --- /dev/null +++ b/linkedin_mcp_server/setup.py @@ -0,0 +1,137 @@ +""" +Interactive setup flows for LinkedIn MCP Server authentication. + +Handles session creation through interactive browser login using Patchright +with persistent context. Profile state auto-persists to user_data_dir. +""" + +import asyncio +from pathlib import Path + +from linkedin_mcp_server.core import ( + BrowserManager, + resolve_remember_me_prompt, + wait_for_manual_login, + warm_up_browser, +) +from linkedin_mcp_server.session_state import portable_cookie_path, write_source_state + +from linkedin_mcp_server.drivers.browser import get_profile_dir + + +async def interactive_login( + user_data_dir: Path | None = None, warm_up: bool = True +) -> bool: + """ + Open browser for manual LinkedIn login with persistent profile. + + Opens a non-headless browser, navigates to LinkedIn login page, + and waits for user to complete authentication (including 2FA, captcha, etc.). + Profile state auto-persists to user_data_dir. + + Args: + user_data_dir: Path to browser profile. Defaults to config's user_data_dir. + warm_up: Visit normal sites first to appear more human-like (default: True) + + Returns: + True if login was successful + + Raises: + Exception: If login fails or times out + """ + if user_data_dir is None: + user_data_dir = get_profile_dir() + + print("Opening browser for LinkedIn login...") + print(" Please log in manually. You have 5 minutes to complete authentication.") + print(" (This handles 2FA, captcha, and any security challenges)") + + async with BrowserManager(user_data_dir=user_data_dir, headless=False) as browser: + # Warm up browser to appear more human-like and avoid security checkpoints + if warm_up: + print(" Warming up browser (visiting normal sites first)...") + await warm_up_browser(browser.page) + + # Navigate to LinkedIn login + await browser.page.goto("https://www.linkedin.com/login") + # Let LinkedIn finish rendering the saved-account chooser, then retry the + # same exact click target a few times before falling back to the normal + # manual-login wait loop. + for _ in range(3): + await asyncio.sleep(2) + if await resolve_remember_me_prompt(browser.page): + break + + # Wait for manual login completion + # 5 minute timeout (300000ms) allows time for 2FA, captcha, security challenges + await wait_for_manual_login(browser.page, timeout=300000) + + # Wait for persistent context to flush cookies to disk + await asyncio.sleep(2) + + # Verify session cookie was persisted + cookies = await browser.context.cookies() + li_at = [c for c in cookies if c["name"] == "li_at"] + if not li_at: + print(" Warning: Session cookie not found. Login may not have persisted.") + print(" Waiting longer for cookie propagation...") + await asyncio.sleep(5) + + # Export source-session cookies for the one-time foreign-runtime bridge. + # Docker now checkpoint-commits its own derived runtime profile after the + # first successful /feed/ recovery instead of relying on browser teardown. + if await browser.export_cookies(portable_cookie_path(user_data_dir)): + print(" Cookies exported for Docker portability") + source_state = write_source_state(user_data_dir) + print(f" Source session generation: {source_state.login_generation}") + else: + print( + " Warning: cookie export failed; Docker bridge may not work. " + "Run --login again to retry." + ) + return False + print(f"Profile saved to {user_data_dir}") + return True + + +def run_profile_creation(user_data_dir: str | None = None) -> bool: + """ + Create profile via interactive login with persistent context. + + Args: + user_data_dir: Path to profile directory. Defaults to config's user_data_dir. + + Returns: + True if profile was created successfully + """ + if user_data_dir: + profile_dir = Path(user_data_dir).expanduser() + else: + profile_dir = get_profile_dir() + + print("LinkedIn MCP Server - Profile Creation") + print(f" Profile will be saved to: {profile_dir}") + + try: + success = asyncio.run(interactive_login(profile_dir)) + return success + except Exception as e: + print(f"Profile creation failed: {e}") + return False + + +def run_interactive_setup() -> bool: + """ + Run interactive setup - browser login only. + + Returns: + True if setup completed successfully + """ + print("LinkedIn MCP Server Setup") + print(" Opening browser for manual login...") + + try: + return asyncio.run(interactive_login()) + except Exception as e: + print(f"Login failed: {e}") + return False diff --git a/linkedin_mcp_server/tools/__init__.py b/linkedin_mcp_server/tools/__init__.py new file mode 100644 index 00000000..5852ca2a --- /dev/null +++ b/linkedin_mcp_server/tools/__init__.py @@ -0,0 +1,20 @@ +# src/linkedin_mcp_server/tools/__init__.py +""" +LinkedIn scraping tools package. + +This package contains the MCP tool implementations for LinkedIn data extraction. +Each tool module provides specific functionality for different LinkedIn entities +while sharing common error handling and driver management patterns. + +Available Tools: +- Person tools: LinkedIn profile scraping and analysis +- Company tools: Company profile and information extraction +- Job tools: Job posting details and search functionality + +Architecture: +- FastMCP integration for MCP-compliant tool registration +- Depends()-based dependency injection for browser/extractor setup +- ToolError-based error handling through centralized raise_tool_error() +- Singleton driver pattern for session persistence +- Structured data return format for consistent MCP responses +""" diff --git a/linkedin_mcp_server/tools/company.py b/linkedin_mcp_server/tools/company.py new file mode 100644 index 00000000..681b8ec5 --- /dev/null +++ b/linkedin_mcp_server/tools/company.py @@ -0,0 +1,136 @@ +""" +LinkedIn company profile scraping tools. + +Uses innerText extraction for resilient company data capture +with configurable section selection. +""" + +import logging +from typing import Any + +from fastmcp import Context, FastMCP +from fastmcp.dependencies import Depends + +from linkedin_mcp_server.constants import TOOL_TIMEOUT_SECONDS +from linkedin_mcp_server.dependencies import get_extractor +from linkedin_mcp_server.error_handler import raise_tool_error +from linkedin_mcp_server.scraping import LinkedInExtractor, parse_company_sections +from linkedin_mcp_server.scraping.extractor import _RATE_LIMITED_MSG +from linkedin_mcp_server.scraping.link_metadata import Reference + +logger = logging.getLogger(__name__) + + +def register_company_tools(mcp: FastMCP) -> None: + """Register all company-related tools with the MCP server.""" + + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Get Company Profile", + annotations={"readOnlyHint": True, "openWorldHint": True}, + tags={"company", "scraping"}, + ) + async def get_company_profile( + company_name: str, + ctx: Context, + sections: str | None = None, + extractor: LinkedInExtractor = Depends(get_extractor), + ) -> dict[str, Any]: + """ + Get a specific company's LinkedIn profile. + + Args: + company_name: LinkedIn company name (e.g., "docker", "anthropic", "microsoft") + ctx: FastMCP context for progress reporting + sections: Comma-separated list of extra sections to scrape. + The about page is always included. + Available sections: posts, jobs + Examples: "posts", "posts,jobs" + Default (None) scrapes only the about page. + + Returns: + Dict with url, sections (name -> raw text), and optional references. + Includes unknown_sections list when unrecognised names are passed. + The LLM should parse the raw text in each section. + """ + try: + requested, unknown = parse_company_sections(sections) + + logger.info( + "Scraping company: %s (sections=%s)", + company_name, + sections, + ) + + await ctx.report_progress( + progress=0, total=100, message="Starting company profile scrape" + ) + + result = await extractor.scrape_company(company_name, requested) + + if unknown: + result["unknown_sections"] = unknown + + await ctx.report_progress(progress=100, total=100, message="Complete") + + return result + + except Exception as e: + raise_tool_error(e, "get_company_profile") # NoReturn + + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Get Company Posts", + annotations={"readOnlyHint": True, "openWorldHint": True}, + tags={"company", "scraping"}, + ) + async def get_company_posts( + company_name: str, + ctx: Context, + extractor: LinkedInExtractor = Depends(get_extractor), + ) -> dict[str, Any]: + """ + Get recent posts from a company's LinkedIn feed. + + Args: + company_name: LinkedIn company name (e.g., "docker", "anthropic", "microsoft") + ctx: FastMCP context for progress reporting + + Returns: + Dict with url, sections (name -> raw text), and optional references. + The LLM should parse the raw text to extract individual posts. + """ + try: + logger.info("Scraping company posts: %s", company_name) + + await ctx.report_progress( + progress=0, total=100, message="Starting company posts scrape" + ) + + url = f"https://www.linkedin.com/company/{company_name}/posts/" + extracted = await extractor.extract_page(url, section_name="posts") + + sections: dict[str, str] = {} + references: dict[str, list[Reference]] = {} + section_errors: dict[str, dict[str, Any]] = {} + if extracted.text and extracted.text != _RATE_LIMITED_MSG: + sections["posts"] = extracted.text + if extracted.references: + references["posts"] = extracted.references + elif extracted.error: + section_errors["posts"] = extracted.error + + await ctx.report_progress(progress=100, total=100, message="Complete") + + result = { + "url": url, + "sections": sections, + } + if references: + result["references"] = references + if section_errors: + result["section_errors"] = section_errors + return result + + except Exception as e: + raise_tool_error(e, "get_company_posts") # NoReturn diff --git a/linkedin_mcp_server/tools/job.py b/linkedin_mcp_server/tools/job.py new file mode 100644 index 00000000..dcf365a1 --- /dev/null +++ b/linkedin_mcp_server/tools/job.py @@ -0,0 +1,132 @@ +""" +LinkedIn job scraping tools with search and detail extraction. + +Uses innerText extraction for resilient job data capture. +""" + +import logging +from typing import Annotated, Any + +from fastmcp import Context, FastMCP +from fastmcp.dependencies import Depends +from pydantic import Field + +from linkedin_mcp_server.constants import TOOL_TIMEOUT_SECONDS +from linkedin_mcp_server.dependencies import get_extractor +from linkedin_mcp_server.error_handler import raise_tool_error +from linkedin_mcp_server.scraping import LinkedInExtractor + +logger = logging.getLogger(__name__) + + +def register_job_tools(mcp: FastMCP) -> None: + """Register all job-related tools with the MCP server.""" + + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Get Job Details", + annotations={"readOnlyHint": True, "openWorldHint": True}, + tags={"job", "scraping"}, + ) + async def get_job_details( + job_id: str, + ctx: Context, + extractor: LinkedInExtractor = Depends(get_extractor), + ) -> dict[str, Any]: + """ + Get job details for a specific job posting on LinkedIn. + + Args: + job_id: LinkedIn job ID (e.g., "4252026496", "3856789012") + ctx: FastMCP context for progress reporting + + Returns: + Dict with url, sections (name -> raw text), and optional references. + The LLM should parse the raw text to extract job details. + """ + try: + logger.info("Scraping job: %s", job_id) + + await ctx.report_progress( + progress=0, total=100, message="Starting job scrape" + ) + + result = await extractor.scrape_job(job_id) + + await ctx.report_progress(progress=100, total=100, message="Complete") + + return result + + except Exception as e: + raise_tool_error(e, "get_job_details") # NoReturn + + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Search Jobs", + annotations={"readOnlyHint": True, "openWorldHint": True}, + tags={"job", "search"}, + ) + async def search_jobs( + keywords: str, + ctx: Context, + location: str | None = None, + max_pages: Annotated[int, Field(ge=1, le=10)] = 3, + date_posted: str | None = None, + job_type: str | None = None, + experience_level: str | None = None, + work_type: str | None = None, + easy_apply: bool = False, + sort_by: str | None = None, + extractor: LinkedInExtractor = Depends(get_extractor), + ) -> dict[str, Any]: + """ + Search for jobs on LinkedIn. + + Returns job_ids that can be passed to get_job_details for full info. + + Args: + keywords: Search keywords (e.g., "software engineer", "data scientist") + ctx: FastMCP context for progress reporting + location: Optional location filter (e.g., "San Francisco", "Remote") + max_pages: Maximum number of result pages to load (1-10, default 3) + date_posted: Filter by posting date (past_hour, past_24_hours, past_week, past_month) + job_type: Filter by job type, comma-separated (full_time, part_time, contract, temporary, volunteer, internship, other) + experience_level: Filter by experience level, comma-separated (internship, entry, associate, mid_senior, director, executive) + work_type: Filter by work type, comma-separated (on_site, remote, hybrid) + easy_apply: Only show Easy Apply jobs (default false) + sort_by: Sort results (date, relevance) + + Returns: + Dict with url, sections (name -> raw text), job_ids (list of + numeric job ID strings usable with get_job_details), and optional references. + """ + try: + logger.info( + "Searching jobs: keywords='%s', location='%s', max_pages=%d", + keywords, + location, + max_pages, + ) + + await ctx.report_progress( + progress=0, total=100, message="Starting job search" + ) + + result = await extractor.search_jobs( + keywords, + location=location, + max_pages=max_pages, + date_posted=date_posted, + job_type=job_type, + experience_level=experience_level, + work_type=work_type, + easy_apply=easy_apply, + sort_by=sort_by, + ) + + await ctx.report_progress(progress=100, total=100, message="Complete") + + return result + + except Exception as e: + raise_tool_error(e, "search_jobs") # NoReturn diff --git a/linkedin_mcp_server/tools/person.py b/linkedin_mcp_server/tools/person.py new file mode 100644 index 00000000..afa058bb --- /dev/null +++ b/linkedin_mcp_server/tools/person.py @@ -0,0 +1,122 @@ +""" +LinkedIn person profile scraping tools. + +Uses innerText extraction for resilient profile data capture +with configurable section selection. +""" + +import logging +from typing import Any + +from fastmcp import Context, FastMCP +from fastmcp.dependencies import Depends + +from linkedin_mcp_server.constants import TOOL_TIMEOUT_SECONDS +from linkedin_mcp_server.dependencies import get_extractor +from linkedin_mcp_server.error_handler import raise_tool_error +from linkedin_mcp_server.scraping import LinkedInExtractor, parse_person_sections + +logger = logging.getLogger(__name__) + + +def register_person_tools(mcp: FastMCP) -> None: + """Register all person-related tools with the MCP server.""" + + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Get Person Profile", + annotations={"readOnlyHint": True, "openWorldHint": True}, + tags={"person", "scraping"}, + ) + async def get_person_profile( + linkedin_username: str, + ctx: Context, + sections: str | None = None, + extractor: LinkedInExtractor = Depends(get_extractor), + ) -> dict[str, Any]: + """ + Get a specific person's LinkedIn profile. + + Args: + linkedin_username: LinkedIn username (e.g., "stickerdaniel", "williamhgates") + ctx: FastMCP context for progress reporting + sections: Comma-separated list of extra sections to scrape. + The main profile page is always included. + Available sections: experience, education, interests, honors, languages, contact_info, posts + Examples: "experience,education", "contact_info", "honors,languages", "posts" + Default (None) scrapes only the main profile page. + + Returns: + Dict with url, sections (name -> raw text), and optional references. + Sections may be absent if extraction yielded no content for that page. + Includes unknown_sections list when unrecognised names are passed. + The LLM should parse the raw text in each section. + """ + try: + requested, unknown = parse_person_sections(sections) + + logger.info( + "Scraping profile: %s (sections=%s)", + linkedin_username, + sections, + ) + + await ctx.report_progress( + progress=0, total=100, message="Starting person profile scrape" + ) + + result = await extractor.scrape_person(linkedin_username, requested) + + if unknown: + result["unknown_sections"] = unknown + + await ctx.report_progress(progress=100, total=100, message="Complete") + + return result + + except Exception as e: + raise_tool_error(e, "get_person_profile") # NoReturn + + @mcp.tool( + timeout=TOOL_TIMEOUT_SECONDS, + title="Search People", + annotations={"readOnlyHint": True, "openWorldHint": True}, + tags={"person", "search"}, + ) + async def search_people( + keywords: str, + ctx: Context, + location: str | None = None, + extractor: LinkedInExtractor = Depends(get_extractor), + ) -> dict[str, Any]: + """ + Search for people on LinkedIn. + + Args: + keywords: Search keywords (e.g., "software engineer", "recruiter at Google") + ctx: FastMCP context for progress reporting + location: Optional location filter (e.g., "New York", "Remote") + + Returns: + Dict with url, sections (name -> raw text), and optional references. + The LLM should parse the raw text to extract individual people and their profiles. + """ + try: + logger.info( + "Searching people: keywords='%s', location='%s'", + keywords, + location, + ) + + await ctx.report_progress( + progress=0, total=100, message="Starting people search" + ) + + result = await extractor.search_people(keywords, location) + + await ctx.report_progress(progress=100, total=100, message="Complete") + + return result + + except Exception as e: + raise_tool_error(e, "search_people") # NoReturn diff --git a/linkedin_mcp_server/utils/__init__.py b/linkedin_mcp_server/utils/__init__.py new file mode 100644 index 00000000..2785acad --- /dev/null +++ b/linkedin_mcp_server/utils/__init__.py @@ -0,0 +1 @@ +"""Utility functions for LinkedIn MCP Server.""" diff --git a/main.py b/main.py deleted file mode 100644 index 6d06a6b7..00000000 --- a/main.py +++ /dev/null @@ -1,68 +0,0 @@ -# main.py -""" -LinkedIn MCP Server - A Model Context Protocol server for LinkedIn integration. - -This is the main entry point that runs the LinkedIn MCP server. -""" - -import sys -import logging -from typing import NoReturn - -from linkedin_mcp_server.arguments import parse_arguments -from linkedin_mcp_server.cli import print_claude_config -from linkedin_mcp_server.drivers.chrome import initialize_driver -from linkedin_mcp_server.server import create_mcp_server, shutdown_handler - - -def main() -> None: - """Initialize and run the LinkedIn MCP server.""" - print("🔗 LinkedIn MCP Server 🔗") - print("=" * 40) - - # Parse command-line arguments - args = parse_arguments() - - # Configure logging - log_level = logging.DEBUG if args.debug else logging.ERROR - logging.basicConfig( - level=log_level, - format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", - ) - - logger = logging.getLogger("linkedin_mcp_server") - logger.debug(f"Server arguments: {args}") - - # Initialize the driver - with lazy initialization if specified - initialize_driver(headless=args.headless, lazy_init=args.lazy_init) - - # Print configuration for Claude if in setup mode - if args.setup: - print_claude_config() - - # Create and run the MCP server - mcp = create_mcp_server() - print("\n🚀 Running LinkedIn MCP server...") - mcp.run(transport="stdio") - - -def exit_gracefully(exit_code: int = 0) -> NoReturn: - """ - Exit the application gracefully, cleaning up resources. - - Args: - exit_code: The exit code to use when terminating - """ - print("\n👋 Shutting down LinkedIn MCP server...") - shutdown_handler() - sys.exit(exit_code) - - -if __name__ == "__main__": - try: - main() - except KeyboardInterrupt: - exit_gracefully(0) - except Exception as e: - print(f"❌ Error running MCP server: {e}") - exit_gracefully(1) diff --git a/manifest.json b/manifest.json new file mode 100644 index 00000000..ad5ca8e9 --- /dev/null +++ b/manifest.json @@ -0,0 +1,81 @@ +{ + "dxt_version": "0.1", + "name": "linkedin-mcp-server", + "display_name": "LinkedIn MCP Server", + "version": "4.4.1", + "description": "Connect Claude to LinkedIn for profiles, companies, job details, and people search", + "long_description": "# LinkedIn MCP Server\n\nConnect Claude to your LinkedIn account. Access profiles, companies, and job postings through a Docker container on your machine.\n\n## Features\n- **Profile Access**: Get detailed LinkedIn profile information including work history, education, and skills\n- **Company Profiles**: Extract comprehensive company information and details\n- **Job Details**: Retrieve job posting information from LinkedIn URLs\n- **Job Search**: Search for jobs with keywords and location filters\n- **People Search**: Search for people by keywords and location\n- **Company Posts**: Get recent posts from a company's LinkedIn feed\n- **Person Posts**: Get recent activity and posts from a person's profile\n\n## First-Time Setup\n\n### 1. Pre-pull Docker Image (Required)\nRun this command first to avoid connection timeouts:\n```\ndocker pull stickerdaniel/linkedin-mcp-server:4.4.1", + "author": { + "name": "Daniel Sticker", + "email": "daniel@sticker.name", + "url": "https://daniel.sticker.name/" + }, + "homepage": "https://github.com/stickerdaniel/linkedin-mcp-server", + "documentation": "https://github.com/stickerdaniel/linkedin-mcp-server#readme", + "support": "https://github.com/stickerdaniel/linkedin-mcp-server/issues", + "license": "MIT", + "keywords": ["linkedin", "scraping", "mcp", "profiles", "companies", "jobs", "people", "search", "posts"], + "icon": "assets/icons/linkedin.svg", + "screenshots": ["assets/screenshots/screenshot.png"], + "server": { + "type": "binary", + "entry_point": "docker", + "mcp_config": { + "command": "docker", + "args": [ + "run", "--rm", "-i", + "-v", "${HOME}/.linkedin-mcp:/home/pwuser/.linkedin-mcp", + "-e", "LOG_LEVEL=DEBUG", + "stickerdaniel/linkedin-mcp-server:4.4.1" + ] + } + }, + "tools": [ + { + "name": "get_person_profile", + "description": "Get detailed information from a LinkedIn profile including work history, education, skills, connections, and recent posts" + }, + { + "name": "get_company_profile", + "description": "Extract comprehensive company information and details" + }, + { + "name": "get_company_posts", + "description": "Get recent posts from a company's LinkedIn feed" + }, + { + "name": "get_job_details", + "description": "Retrieve specific job posting details using LinkedIn job IDs" + }, + { + "name": "search_jobs", + "description": "Search for jobs with filters like keywords and location" + }, + { + "name": "search_people", + "description": "Search for people on LinkedIn by keywords and location" + }, + { + "name": "close_session", + "description": "Properly close browser session and clean up resources" + } + ], + "user_config": { + "AUTH": { + "description": "Set to 'oauth' to enable OAuth 2.1 authentication for remote deployments", + "required": false + }, + "OAUTH_BASE_URL": { + "description": "Public URL of the server (required when AUTH=oauth)", + "required": false + }, + "OAUTH_PASSWORD": { + "description": "Password for the OAuth login page (required when AUTH=oauth)", + "required": false + } + }, + "compatibility": { + "claude_desktop": ">=0.10.0", + "platforms": ["darwin", "linux", "win32"] + } +} diff --git a/pyproject.toml b/pyproject.toml index 8e14fe07..2df7dfaf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,18 +1,73 @@ [project] -name = "linkedin-mcp-server" -version = "0.1.0" -description = "Add your description here" +name = "linkedin-scraper-mcp" +version = "4.4.1" +description = "MCP server for LinkedIn profile, company, and job scraping with Claude AI integration. Supports direct profile/company/job URL scraping with secure credential storage." readme = "README.md" requires-python = ">=3.12" +authors = [ + { name = "Daniel Sticker", email = "daniel@sticker.name" } +] +license = "Apache-2.0" +keywords = [ + "linkedin", + "mcp", + "model-context-protocol", + "scraper", + "ai", + "automation", + "llm", + "anthropic", + "claude", +] +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Topic :: Software Development :: Libraries :: Python Modules", + "Topic :: Internet :: WWW/HTTP :: Dynamic Content", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Environment :: Console", + "Operating System :: OS Independent", +] dependencies = [ - "httpx>=0.28.1", + "fastmcp>=3.0.0", "inquirer>=3.4.0", - "linkedin-scraper", - "mcp[cli]>=1.6.0", - "mypy>=1.15.0", - "pre-commit>=4.2.0", - "pyperclip>=1.9.0", + "patchright>=1.40.0", + "python-dotenv>=1.1.1", ] -[tool.uv.sources] -linkedin-scraper = { git = "https://github.com/stickerdaniel/linkedin_scraper.git" } +[project.urls] +Homepage = "https://github.com/stickerdaniel/linkedin-mcp-server" +Documentation = "https://github.com/stickerdaniel/linkedin-mcp-server#readme" +Repository = "https://github.com/stickerdaniel/linkedin-mcp-server" +Issues = "https://github.com/stickerdaniel/linkedin-mcp-server/issues" +Changelog = "https://github.com/stickerdaniel/linkedin-mcp-server/releases" + +[project.scripts] +linkedin-mcp-server = "linkedin_mcp_server.cli_main:main" +linkedin-scraper-mcp = "linkedin_mcp_server.cli_main:main" + +[build-system] +requires = ["setuptools>=68.0", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.setuptools.packages.find] +include = ["linkedin_mcp_server*"] +exclude = ["assets*", "docs*", "tests*"] + +[tool.setuptools.package-data] +linkedin_mcp_server = ["py.typed"] + +[dependency-groups] +dev = [ + "aiohttp>=3.12.13", + "pre-commit>=4.2.0", + "pytest>=8.3.5", + "pytest-asyncio>=1.0.0", + "pytest-cov>=6.1.1", + "pytest-xdist>=3.8.0", + "ruff>=0.11.11", + "ty>=0.0.1a12", +] diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..b19b464a --- /dev/null +++ b/pytest.ini @@ -0,0 +1,5 @@ +[pytest] +testpaths = tests +asyncio_mode = auto +asyncio_default_fixture_loop_scope = function +addopts = -v --strict-markers -ra diff --git a/renovate.json b/renovate.json new file mode 100644 index 00000000..5190dc4b --- /dev/null +++ b/renovate.json @@ -0,0 +1,35 @@ +{ + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "extends": ["config:best-practices", "group:allNonMajor"], + "schedule": ["before 6am on Monday"], + "vulnerabilityAlerts": { + "enabled": true, + "labels": ["security"], + "schedule": ["at any time"] + }, + "packageRules": [ + { + "description": "Managed by release workflow, not Renovate", + "matchPackageNames": ["stickerdaniel/linkedin-mcp-server"], + "matchManagers": ["docker-compose"], + "enabled": false + }, + { + "description": "Group all CI dependencies (GitHub Actions + Docker)", + "matchManagers": ["github-actions", "dockerfile", "docker-compose"], + "matchPackageNames": ["!stickerdaniel/linkedin-mcp-server"], + "groupName": "CI dependencies" + }, + { + "description": "Group all major updates together", + "matchUpdateTypes": ["major"], + "groupName": "all major dependencies" + }, + { + "description": "Group MCP ecosystem packages", + "matchPackageNames": ["fastmcp", "mcp"], + "matchUpdateTypes": ["minor", "patch"], + "groupName": "MCP ecosystem" + } + ] +} diff --git a/scripts/debug_cookie_bridge.py b/scripts/debug_cookie_bridge.py new file mode 100644 index 00000000..e5761169 --- /dev/null +++ b/scripts/debug_cookie_bridge.py @@ -0,0 +1,353 @@ +"""Manual cookie-bridge debugger for cross-platform LinkedIn sessions. + +This script is intentionally not part of the automated test suite. Use it +sparingly to inspect how a host-authenticated session behaves when replayed +into a fresh browser profile, including Docker/Linux runs. +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import shutil +import tempfile +from pathlib import Path +from typing import Any, cast + +from linkedin_mcp_server.common_utils import slugify_fragment +from linkedin_mcp_server.core.auth import detect_auth_barrier, is_logged_in +from linkedin_mcp_server.core.browser import BrowserManager + + +DEFAULT_TARGET_URL = "https://www.linkedin.com/in/williamhgates/" +_SETTLE_DELAY_SECONDS = 10.0 + +COOKIE_PRESETS: dict[str, set[str] | None] = { + "li_at_only": {"li_at"}, + "auth_minimal": {"li_at", "JSESSIONID", "bcookie", "bscookie", "lidc"}, + "auth_only": {"li_at", "li_rm"}, + "bridge_core": { + "li_at", + "li_rm", + "JSESSIONID", + "bcookie", + "bscookie", + "liap", + "lidc", + "li_gc", + "lang", + "timezone", + "li_mc", + }, + "full": None, +} + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--cookie-path", + type=Path, + default=Path.home() / ".linkedin-mcp" / "cookies.json", + help="Path to portable LinkedIn cookie JSON", + ) + parser.add_argument( + "--candidate", + choices=sorted(COOKIE_PRESETS), + default="bridge_core", + help="Cookie subset to replay", + ) + parser.add_argument( + "--target-url", + default=DEFAULT_TARGET_URL, + help="Authenticated page to probe after bridge replay", + ) + parser.add_argument( + "--pre-nav", + action=argparse.BooleanOptionalAction, + default=True, + help="Navigate to /feed before importing cookies", + ) + parser.add_argument( + "--clear-existing", + action=argparse.BooleanOptionalAction, + default=False, + help="Clear fresh browser cookies before import", + ) + parser.add_argument( + "--body-lines", + type=int, + default=20, + help="Number of non-empty body lines to include in the report", + ) + parser.add_argument( + "--output", + type=Path, + help="Optional path to write JSON report", + ) + parser.add_argument( + "--artifact-dir", + type=Path, + help="Optional directory for screenshots and other debug artifacts", + ) + parser.add_argument( + "--checkpoint-restart", + action=argparse.BooleanOptionalAction, + default=True, + help="Close and reopen the same profile after a successful bridge replay", + ) + return parser.parse_args() + + +def load_portable_cookies( + cookie_path: Path, + candidate: str, +) -> list[dict[str, Any]]: + all_cookies = json.loads(cookie_path.read_text()) + normalized = [ + _normalize_cookie_domain(cookie) + for cookie in all_cookies + if "linkedin.com" in cookie.get("domain", "") + ] + keep_names = COOKIE_PRESETS[candidate] + if keep_names is None: + return normalized + return [cookie for cookie in normalized if cookie.get("name") in keep_names] + + +def _normalize_cookie_domain(cookie: dict[str, Any]) -> dict[str, Any]: + domain = cookie.get("domain", "") + if domain in (".www.linkedin.com", "www.linkedin.com"): + return {**cookie, "domain": ".linkedin.com"} + return cookie + + +async def capture_page_state(page, *, body_lines: int) -> dict[str, Any]: + try: + title = await page.title() + except Exception as exc: # pragma: no cover - best effort diagnostics + title = f"" + + try: + body_text = await page.locator("body").inner_text(timeout=3000) + except Exception as exc: # pragma: no cover - best effort diagnostics + body_text = f"" + + body_lines_trimmed = [] + if isinstance(body_text, str) and not body_text.startswith(" str: + return slugify_fragment(step) + + +def _resolve_artifact_dir(args: argparse.Namespace) -> Path | None: + if args.artifact_dir: + return args.artifact_dir.expanduser().resolve() + if args.output: + return args.output.expanduser().resolve().with_suffix("").parent / ( + args.output.stem + "_artifacts" + ) + return None + + +async def capture_screenshot(page, step: str, artifact_dir: Path | None) -> str | None: + if artifact_dir is None: + return None + + artifact_dir.mkdir(parents=True, exist_ok=True) + path = artifact_dir / f"{_slugify_step(step)}.png" + try: + await page.screenshot(path=str(path), full_page=True) + return str(path) + except Exception as exc: # pragma: no cover - best effort diagnostics + return f"" + + +async def safe_goto(page, url: str) -> dict[str, Any]: + try: + await page.goto(url, wait_until="domcontentloaded", timeout=15000) + return {"ok": True} + except Exception as exc: # pragma: no cover - best effort diagnostics + return {"ok": False, "error": f"{type(exc).__name__}: {exc}"} + + +async def settle_page(page) -> None: + """Give LinkedIn time to finish redirects and hydrate content.""" + await asyncio.sleep(_SETTLE_DELAY_SECONDS) + try: + await page.wait_for_load_state("networkidle", timeout=5000) + except Exception: # pragma: no cover - best effort diagnostics + pass + await asyncio.sleep(1) + + +async def _capture_step( + report: dict[str, Any], + page, + *, + step: str, + body_lines: int, + artifact_dir: Path | None, +) -> None: + await settle_page(page) + report[f"{step}_screenshot"] = await capture_screenshot(page, step, artifact_dir) + report[step] = await capture_page_state(page, body_lines=body_lines) + + +async def run_debug(args: argparse.Namespace) -> dict[str, Any]: + imported_cookies = load_portable_cookies(args.cookie_path, args.candidate) + artifact_dir = _resolve_artifact_dir(args) + + temp_dir = Path(tempfile.mkdtemp(prefix="linkedin-cookie-debug-")) + profile_dir = temp_dir / "profile" + + report: dict[str, Any] = { + "cookie_path": str(args.cookie_path), + "candidate": args.candidate, + "import_cookie_names": [cookie["name"] for cookie in imported_cookies], + "pre_nav": args.pre_nav, + "clear_existing": args.clear_existing, + "checkpoint_restart": args.checkpoint_restart, + "target_url": args.target_url, + "temp_profile_dir": str(profile_dir), + } + if artifact_dir is not None: + report["artifact_dir"] = str(artifact_dir) + + browser = BrowserManager(user_data_dir=profile_dir, headless=True) + browser_closed = False + try: + await browser.start() + await _capture_step( + report, + browser.page, + step="start", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + + if args.pre_nav: + report["pre_nav_result"] = await safe_goto( + browser.page, + "https://www.linkedin.com/feed/", + ) + await _capture_step( + report, + browser.page, + step="after_pre_nav", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + + if args.clear_existing: + await browser.context.clear_cookies() + + await browser.context.add_cookies(cast(Any, imported_cookies)) + await _capture_step( + report, + browser.page, + step="after_import", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + + report["feed_nav_result"] = await safe_goto( + browser.page, + "https://www.linkedin.com/feed/", + ) + await _capture_step( + report, + browser.page, + step="after_feed_nav", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + + report["target_nav_result"] = await safe_goto(browser.page, args.target_url) + await _capture_step( + report, + browser.page, + step="after_target_nav", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + + if args.checkpoint_restart: + storage_state_path = temp_dir / "storage-state.json" + report["storage_state_exported"] = await browser.export_storage_state( + storage_state_path, indexed_db=True + ) + report["storage_state_path"] = str(storage_state_path) + await browser.close() + browser_closed = True + + reopened = BrowserManager(user_data_dir=profile_dir, headless=True) + try: + await reopened.start() + report["reopened_feed_nav_result"] = await safe_goto( + reopened.page, + "https://www.linkedin.com/feed/", + ) + await _capture_step( + report, + reopened.page, + step="after_reopened_feed_nav", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + + report["reopened_target_nav_result"] = await safe_goto( + reopened.page, + args.target_url, + ) + await _capture_step( + report, + reopened.page, + step="after_reopened_target_nav", + body_lines=args.body_lines, + artifact_dir=artifact_dir, + ) + finally: + await reopened.close() + return report + finally: + if not browser_closed: + await browser.close() + shutil.rmtree(temp_dir, ignore_errors=True) + + +def main() -> None: + args = parse_args() + report = asyncio.run(run_debug(args)) + rendered = json.dumps(report, indent=2, ensure_ascii=True) + if args.output: + args.output.write_text(rendered + "\n") + print(rendered) + + +if __name__ == "__main__": + main() diff --git a/scripts/dump_snapshots.py b/scripts/dump_snapshots.py new file mode 100644 index 00000000..fce54cfc --- /dev/null +++ b/scripts/dump_snapshots.py @@ -0,0 +1,87 @@ +"""Dump LinkedIn scraper output as timestamped local snapshots. + +Uses the same code paths as production (parse_person_sections / parse_company_sections). + +Run: uv run python scripts/dump_snapshots.py +""" + +import asyncio +import json +import sys +from datetime import datetime +from pathlib import Path + +# Add project root to path +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from linkedin_mcp_server.drivers.browser import ( + close_browser, + ensure_authenticated, + get_or_create_browser, + set_headless, +) +from linkedin_mcp_server.scraping import ( + LinkedInExtractor, + parse_company_sections, + parse_person_sections, +) + +OUTPUT_DIR = Path(__file__).parent / "snapshot_dumps" + +# Targets using the same section strings as prod tool calls +PERSON_TARGETS: list[tuple[str, str]] = [ + ("williamhgates", "experience,education,interests,honors,languages,contact_info"), + ("anistji", "experience,education,honors,languages,contact_info"), +] + +COMPANY_TARGETS: list[tuple[str, str]] = [ + ("anthropicresearch", "posts,jobs"), +] + + +async def main(): + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + run_dir = OUTPUT_DIR / timestamp + run_dir.mkdir(parents=True, exist_ok=True) + + set_headless(True) + + try: + await ensure_authenticated() + browser = await get_or_create_browser() + extractor = LinkedInExtractor(browser.page) + + for username, sections_str in PERSON_TARGETS: + print(f"\n--- Scraping person: {username} (sections: {sections_str}) ---") + fields, _ = parse_person_sections(sections_str) + result = await extractor.scrape_person(username, fields) + + dump_path = run_dir / f"person_{username}.json" + dump_path.write_text(json.dumps(result, indent=2, ensure_ascii=False)) + + for section_name, text in result["sections"].items(): + txt_path = run_dir / f"person_{username}_{section_name}.txt" + txt_path.write_text(text) + print(f" {section_name}: {len(text)} chars") + + for company, sections_str in COMPANY_TARGETS: + print(f"\n--- Scraping company: {company} (sections: {sections_str}) ---") + fields, _ = parse_company_sections(sections_str) + result = await extractor.scrape_company(company, fields) + + dump_path = run_dir / f"company_{company}.json" + dump_path.write_text(json.dumps(result, indent=2, ensure_ascii=False)) + + for section_name, text in result["sections"].items(): + txt_path = run_dir / f"company_{company}_{section_name}.txt" + txt_path.write_text(text) + print(f" {section_name}: {len(text)} chars") + + finally: + await close_browser() + + print(f"\n✅ Snapshots saved to {run_dir}/") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/src/linkedin_mcp_server/__init__.py b/src/linkedin_mcp_server/__init__.py deleted file mode 100644 index 512ac925..00000000 --- a/src/linkedin_mcp_server/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -# src/linkedin_mcp_server/__init__.py -"""LinkedIn MCP Server package.""" - -__version__ = "0.1.0" diff --git a/src/linkedin_mcp_server/arguments.py b/src/linkedin_mcp_server/arguments.py deleted file mode 100644 index 96f2ca85..00000000 --- a/src/linkedin_mcp_server/arguments.py +++ /dev/null @@ -1,64 +0,0 @@ -# src/linkedin_mcp_server/arguments.py -""" -Command-line argument parsing for LinkedIn MCP server. - -This module handles parsing and validating command-line arguments. -""" - -import argparse -from dataclasses import dataclass - - -@dataclass -class ServerArguments: - """Command-line arguments for the LinkedIn MCP server.""" - - headless: bool - setup: bool - debug: bool - lazy_init: bool - - -def parse_arguments() -> ServerArguments: - """ - Parse command-line arguments for the LinkedIn MCP server. - - Returns: - ServerArguments: Parsed command-line arguments - """ - parser = argparse.ArgumentParser( - description="LinkedIn MCP Server - A Model Context Protocol server for LinkedIn integration" - ) - - parser.add_argument( - "--no-headless", - action="store_true", - help="Run Chrome with a visible browser window (useful for debugging)", - ) - - parser.add_argument( - "--debug", - action="store_true", - help="Enable debug mode with additional logging", - ) - - parser.add_argument( - "--no-setup", - action="store_true", - help="Skip printing configuration information", - ) - - parser.add_argument( - "--no-lazy-init", - action="store_true", - help="Initialize Chrome driver and login immediately (not recommended for most users)", - ) - - args = parser.parse_args() - - return ServerArguments( - headless=not args.no_headless, - setup=not args.no_setup, - debug=args.debug, - lazy_init=not args.no_lazy_init, # Default to lazy init - ) diff --git a/src/linkedin_mcp_server/cli.py b/src/linkedin_mcp_server/cli.py deleted file mode 100644 index f25a5161..00000000 --- a/src/linkedin_mcp_server/cli.py +++ /dev/null @@ -1,85 +0,0 @@ -# src/linkedin_mcp_server/cli.py -""" -CLI utilities for LinkedIn MCP server. - -This module handles the command-line interface and configuration management. -""" - -from typing import Dict, Any, List -import os -import json -import subprocess -import logging -import pyperclip # type: ignore - -logger = logging.getLogger(__name__) - - -def print_claude_config() -> None: - """ - Print Claude configuration and copy to clipboard. - - This function generates the configuration needed for Claude Desktop - and copies it to the clipboard for easy pasting. - """ - current_dir = os.path.abspath( - os.path.dirname(os.path.dirname(os.path.dirname(__file__))) - ) - - # Find the full path to uv executable - try: - uv_path = subprocess.check_output(["which", "uv"], text=True).strip() - print(f"🔍 Found uv at: {uv_path}") - except subprocess.CalledProcessError: - # Fallback if which uv fails - uv_path = "uv" - print( - "⚠ī¸ Could not find full path to uv, using 'uv' directly. " - "This may not work in Claude Desktop." - ) - - # Include useful command-line arguments in the default args - args: List[str] = [ - "--directory", - current_dir, - "run", - "main.py", - "--no-setup", - ] # , "--no-lazy-init"] - - config_json: Dict[str, Any] = { - "mcpServers": { - "linkedin-scraper": { - "command": uv_path, - "args": args, - "disabled": False, - "requiredTools": [ - "get_person_profile", - "get_company_profile", - "get_job_details", - "search_jobs", - ], - } - } - } - - # Convert to string for clipboard - config_str = json.dumps(config_json, indent=2) - - # Print the final configuration - print("\n📋 Your Claude configuration should look like:") - print(config_str) - print( - "\n🔧 Add this to your Claude Desktop configuration in Settings > Developer > Edit Config" - ) - - # Copy to clipboard - try: - pyperclip.copy(config_str) # Only copy the JSON, not the comments - print("✅ Claude configuration copied to clipboard!") - except ImportError: - print( - "⚠ī¸ pyperclip not installed. To copy configuration automatically, run: uv add pyperclip" - ) - except Exception as e: - print(f"❌ Could not copy to clipboard: {e}") diff --git a/src/linkedin_mcp_server/credentials.py b/src/linkedin_mcp_server/credentials.py deleted file mode 100644 index 79d4ad97..00000000 --- a/src/linkedin_mcp_server/credentials.py +++ /dev/null @@ -1,86 +0,0 @@ -# src/linkedin_mcp_server/credentials.py -""" -Credential management for LinkedIn MCP server. - -This module handles the secure storage and retrieval of LinkedIn credentials. -""" - -from typing import Dict, Optional -import os -import json -from pathlib import Path -import logging -import inquirer - -logger = logging.getLogger(__name__) - - -def get_credentials(non_interactive: bool = False) -> Optional[Dict[str, str]]: - """ - Get LinkedIn credentials from environment variables, stored file, or prompt. - - Args: - non_interactive: If True, only get credentials from environment or stored file, - without prompting the user. - - Returns: - Optional[Dict[str, str]]: Dictionary containing email and password, or None if - not available in non-interactive mode. - """ - # First, try environment variables - email = os.environ.get("LINKEDIN_EMAIL") - password = os.environ.get("LINKEDIN_PASSWORD") - - if email and password: - logger.info("Using LinkedIn credentials from environment variables") - return {"email": email, "password": password} - - # Second, try stored credentials file - credentials_file = Path.home() / ".linkedin_mcp_credentials.json" - if credentials_file.exists(): - try: - with open(credentials_file, "r") as f: - credentials = json.load(f) - if "email" in credentials and "password" in credentials: - logger.info("Using LinkedIn credentials from stored file") - return credentials - except Exception as e: - logger.error(f"Error reading credentials file: {e}") - - # If in non-interactive mode and we haven't found credentials yet, return None - if non_interactive: - logger.warning("No credentials found in non-interactive mode") - return None - - # Otherwise, prompt for credentials - return prompt_for_credentials() - - -def prompt_for_credentials() -> Dict[str, str]: - """ - Prompt user for LinkedIn credentials and store them. - - Returns: - Dict[str, str]: Dictionary containing email and password - """ - print("🔑 LinkedIn credentials required") - questions = [ - inquirer.Text("email", message="LinkedIn Email"), - inquirer.Password("password", message="LinkedIn Password"), - ] - credentials = inquirer.prompt(questions) - - # Store credentials securely - try: - credentials_file = Path.home() / ".linkedin_mcp_credentials.json" - with open(credentials_file, "w") as f: - json.dump(credentials, f) - - # Set permissions to user-only read/write - os.chmod(credentials_file, 0o600) - print(f"✅ Credentials stored with user-only read/write at {credentials_file}") - except Exception as e: - logger.warning(f"Could not store credentials: {e}") - print(f"⚠ī¸ Warning: Could not store credentials: {e}") - - return credentials diff --git a/src/linkedin_mcp_server/drivers/__init__.py b/src/linkedin_mcp_server/drivers/__init__.py deleted file mode 100644 index e93f62bb..00000000 --- a/src/linkedin_mcp_server/drivers/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -# src/linkedin_mcp_server/drivers/__init__.py -"""Driver management for LinkedIn scraping.""" diff --git a/src/linkedin_mcp_server/drivers/chrome.py b/src/linkedin_mcp_server/drivers/chrome.py deleted file mode 100644 index 306f3437..00000000 --- a/src/linkedin_mcp_server/drivers/chrome.py +++ /dev/null @@ -1,333 +0,0 @@ -# src/linkedin_mcp_server/drivers/chrome.py -""" -Chrome driver management for LinkedIn scraping. - -This module handles the creation and management of Chrome WebDriver instances. -""" - -from typing import Dict, Optional, List, Any -import os -import sys -import logging -from pathlib import Path -import inquirer -from selenium import webdriver -from selenium.webdriver.chrome.options import Options -from selenium.webdriver.chrome.service import Service -from selenium.common.exceptions import WebDriverException - -from linkedin_mcp_server.credentials import get_credentials - -# Global driver storage to reuse sessions -active_drivers: Dict[str, webdriver.Chrome] = {} -is_initialized: bool = False -driver_config: Dict[str, Any] = { - "headless": True, - "non_interactive": False, -} - -logger = logging.getLogger(__name__) - - -def get_chromedriver_path() -> Optional[str]: - """ - Get the ChromeDriver path from environment variable or default locations. - - Returns: - Optional[str]: Path to the ChromeDriver executable if found, None otherwise - """ - # First check environment variable - chromedriver_path = os.getenv("CHROMEDRIVER") - if chromedriver_path and os.path.exists(chromedriver_path): - return chromedriver_path - - # Check common locations - possible_paths: List[str] = [ - os.path.join(os.path.dirname(__file__), "../../../drivers/chromedriver"), - os.path.join(os.path.expanduser("~"), "chromedriver"), - "/usr/local/bin/chromedriver", - "/usr/bin/chromedriver", - # Common MacOS paths - "/opt/homebrew/bin/chromedriver", - "/Applications/chromedriver", - # Common Windows paths - "C:\\Program Files\\chromedriver.exe", - "C:\\Program Files (x86)\\chromedriver.exe", - ] - - for path in possible_paths: - if os.path.exists(path) and (os.access(path, os.X_OK) or path.endswith(".exe")): - return path - - return None - - -def configure_driver(headless: bool = True, non_interactive: bool = False) -> None: - """ - Configure the driver settings without initializing it. - - Args: - headless: Whether to run Chrome in headless mode - non_interactive: Whether to run in non-interactive mode (for Docker/CI) - """ - global driver_config - driver_config["headless"] = headless - driver_config["non_interactive"] = non_interactive - logger.info( - f"Driver configured: headless={headless}, non_interactive={non_interactive}" - ) - - -def get_or_create_driver() -> Optional[webdriver.Chrome]: - """ - Get existing driver or create a new one using the configured settings. - - Returns: - Optional[webdriver.Chrome]: Chrome WebDriver instance or None if initialization fails - in non-interactive mode - - Raises: - WebDriverException: If the driver cannot be created and not in non-interactive mode - """ - global is_initialized - session_id = "default" # We use a single session for simplicity - - # Return existing driver if available - if session_id in active_drivers: - return active_drivers[session_id] - - headless = driver_config["headless"] - non_interactive = driver_config["non_interactive"] - - # Set up Chrome options - chrome_options = Options() - if headless: - logger.debug("Running Chrome in headless mode") - chrome_options.add_argument("--headless=new") - else: - logger.debug("Running Chrome with visible browser window") - - # Add additional options for stability - chrome_options.add_argument("--no-sandbox") - chrome_options.add_argument("--disable-dev-shm-usage") - chrome_options.add_argument("--disable-gpu") - chrome_options.add_argument("--window-size=1920,1080") - chrome_options.add_argument( - "--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36" - ) - - # Initialize Chrome driver - try: - chromedriver_path = get_chromedriver_path() - if chromedriver_path: - logger.debug(f"Using ChromeDriver at path: {chromedriver_path}") - service = Service(executable_path=chromedriver_path) - driver = webdriver.Chrome(service=service, options=chrome_options) - else: - logger.debug("Using auto-detected ChromeDriver") - driver = webdriver.Chrome(options=chrome_options) - - # Add a page load timeout for safety - driver.set_page_load_timeout(60) - - # Try to log in if we haven't already - if not is_initialized: - if login_to_linkedin(driver, non_interactive): - is_initialized = True - elif non_interactive: - # In non-interactive mode, if login fails, return None - driver.quit() - return None - - active_drivers[session_id] = driver - return driver - except Exception as e: - error_msg = f"Error creating web driver: {e}" - logger.error(error_msg) - - if non_interactive: - logger.error("Failed to initialize driver in non-interactive mode") - return None - - raise WebDriverException(error_msg) - - -def login_to_linkedin(driver: webdriver.Chrome, non_interactive: bool = False) -> bool: - """ - Log in to LinkedIn using stored or provided credentials. - - Args: - driver: Chrome WebDriver instance - non_interactive: Whether to run in non-interactive mode - - Returns: - bool: True if login was successful, False otherwise - """ - # Get credentials - credentials = get_credentials(non_interactive=non_interactive) - - if not credentials: - if non_interactive: - logger.error("No credentials available in non-interactive mode") - return False - else: - logger.error("Failed to obtain LinkedIn credentials") - return False - - try: - from linkedin_scraper import actions - - # Login to LinkedIn - logger.info("Logging in to LinkedIn...") - if not non_interactive: - print("🔑 Logging in to LinkedIn...") - - actions.login(driver, credentials["email"], credentials["password"]) - - if not non_interactive: - print("✅ Successfully logged in to LinkedIn") - logger.info("Successfully logged in to LinkedIn") - return True - except Exception as e: - error_msg = f"Failed to login: {str(e)}" - logger.error(error_msg) - - if not non_interactive: - print(f"❌ {error_msg}") - print( - "⚠ī¸ You might need to confirm the login in your LinkedIn mobile app. " - "Please try again and confirm the login." - ) - - if driver_config["headless"]: - print( - "🔍 Try running with visible browser window to see what's happening: " - "uv run main.py --no-headless" - ) - - retry = inquirer.prompt( - [ - inquirer.Confirm( - "retry", - message="Would you like to try with different credentials?", - default=True, - ), - ] - ) - - if retry and retry.get("retry", False): - # Remove old credentials and try again - credentials_file = Path.home() / ".linkedin_mcp_credentials.json" - if credentials_file.exists(): - os.remove(credentials_file) - # Try again with new credentials - return login_to_linkedin(driver, non_interactive) - - return False - - -def initialize_driver(headless: bool = True, lazy_init: bool = False) -> None: - """ - Initialize the driver configuration and optionally create driver and log in. - - Args: - headless: Whether to run Chrome in headless mode - lazy_init: If True, only configure the driver without creating it - (driver will be created on first tool call) - """ - # Always configure the driver - configure_driver(headless=headless, non_interactive=lazy_init) - - if lazy_init: - logger.info( - "Using lazy initialization - driver will be created on first tool call" - ) - if "LINKEDIN_EMAIL" in os.environ and "LINKEDIN_PASSWORD" in os.environ: - logger.info("LinkedIn credentials found in environment variables") - else: - logger.warning( - "No LinkedIn credentials in environment variables - will look for stored credentials on first use" - ) - return - - # Validate chromedriver can be found - chromedriver_path = get_chromedriver_path() - - if chromedriver_path: - print(f"✅ ChromeDriver found at: {chromedriver_path}") - os.environ["CHROMEDRIVER"] = chromedriver_path - else: - print("⚠ī¸ ChromeDriver not found in common locations.") - print("⚡ Continuing with automatic detection...") - print( - "💡 Tip: For better results, install ChromeDriver and set the CHROMEDRIVER environment variable" - ) - - # Create driver and log in - try: - driver = get_or_create_driver() - if driver: - print("✅ Web driver initialized successfully") - print( - f"🌐 Browser is running in {'headless' if headless else 'visible'} mode" - ) - else: - print("❌ Failed to initialize web driver.") - except WebDriverException as e: - print(f"❌ Failed to initialize web driver: {str(e)}") - handle_driver_error(headless) - - -def handle_driver_error(headless: bool) -> None: - """ - Handle ChromeDriver initialization errors by providing helpful options. - - Args: - headless: Whether Chrome is running in headless mode - """ - questions = [ - inquirer.List( - "chromedriver_action", - message="What would you like to do?", - choices=[ - ("Specify ChromeDriver path manually", "specify"), - ("Get help installing ChromeDriver", "help"), - ("Exit", "exit"), - ], - ), - ] - answers = inquirer.prompt(questions) - - if answers["chromedriver_action"] == "specify": - path = inquirer.prompt( - [inquirer.Text("custom_path", message="Enter ChromeDriver path")] - )["custom_path"] - - if os.path.exists(path): - os.environ["CHROMEDRIVER"] = path - print(f"✅ ChromeDriver path set to: {path}") - # Try again with the new path - initialize_driver(headless=headless) - else: - print(f"⚠ī¸ Warning: The specified path does not exist: {path}") - initialize_driver(headless=headless) - - elif answers["chromedriver_action"] == "help": - print("\n📋 ChromeDriver Installation Guide:") - print("1. Find your Chrome version: Chrome menu > Help > About Google Chrome") - print( - "2. Download matching ChromeDriver: https://chromedriver.chromium.org/downloads" - ) - print("3. Place ChromeDriver in a location on your PATH") - print(" - macOS/Linux: /usr/local/bin/ is recommended") - print( - " - Windows: Add to a directory in your PATH or specify the full path\n" - ) - - if inquirer.prompt( - [inquirer.Confirm("try_again", message="Try again?", default=True)] - )["try_again"]: - initialize_driver(headless=headless) - - print("❌ ChromeDriver is required for this application to work properly.") - sys.exit(1) diff --git a/src/linkedin_mcp_server/server.py b/src/linkedin_mcp_server/server.py deleted file mode 100644 index 8cb959a6..00000000 --- a/src/linkedin_mcp_server/server.py +++ /dev/null @@ -1,61 +0,0 @@ -# src/linkedin_mcp_server/server.py -""" -MCP server setup for LinkedIn integration. - -This module creates the MCP server and registers all the LinkedIn tools. -""" - -from typing import Dict, Any -from mcp.server.fastmcp import FastMCP - -from linkedin_mcp_server.drivers.chrome import active_drivers -from linkedin_mcp_server.tools.person import register_person_tools -from linkedin_mcp_server.tools.company import register_company_tools -from linkedin_mcp_server.tools.job import register_job_tools - - -def create_mcp_server() -> FastMCP: - """Create and configure the MCP server with all LinkedIn tools.""" - mcp = FastMCP("linkedin_scraper") - - # Register all tools - register_person_tools(mcp) - register_company_tools(mcp) - register_job_tools(mcp) - - # Register session management tool - @mcp.tool() - async def close_session() -> Dict[str, Any]: - """Close the current browser session and clean up resources.""" - session_id = "default" # Using the same default session - - if session_id in active_drivers: - try: - active_drivers[session_id].quit() - del active_drivers[session_id] - return { - "status": "success", - "message": "Successfully closed the browser session", - } - except Exception as e: - return { - "status": "error", - "message": f"Error closing browser session: {str(e)}", - } - else: - return { - "status": "warning", - "message": "No active browser session to close", - } - - return mcp - - -def shutdown_handler() -> None: - """Clean up resources on shutdown.""" - for session_id, driver in list(active_drivers.items()): - try: - driver.quit() - del active_drivers[session_id] - except Exception as e: - print(f"❌ Error closing driver during shutdown: {e}") diff --git a/src/linkedin_mcp_server/tools/__init__.py b/src/linkedin_mcp_server/tools/__init__.py deleted file mode 100644 index 23416850..00000000 --- a/src/linkedin_mcp_server/tools/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -# src/linkedin_mcp_server/tools/__init__.py -"""Tools for LinkedIn scraping.""" diff --git a/src/linkedin_mcp_server/tools/company.py b/src/linkedin_mcp_server/tools/company.py deleted file mode 100644 index 071797d2..00000000 --- a/src/linkedin_mcp_server/tools/company.py +++ /dev/null @@ -1,95 +0,0 @@ -# src/linkedin_mcp_server/tools/company.py -""" -Company profile tools for LinkedIn MCP server. - -This module provides tools for scraping LinkedIn company profiles. -""" - -from typing import Dict, Any, List -from mcp.server.fastmcp import FastMCP -from linkedin_scraper import Company - -from linkedin_mcp_server.drivers.chrome import get_or_create_driver - - -def register_company_tools(mcp: FastMCP) -> None: - """ - Register all company-related tools with the MCP server. - - Args: - mcp (FastMCP): The MCP server instance - """ - - @mcp.tool() - async def get_company_profile( - linkedin_url: str, get_employees: bool = False - ) -> Dict[str, Any]: - """ - Scrape a company's LinkedIn profile. - - Args: - linkedin_url (str): The LinkedIn URL of the company's profile - get_employees (bool): Whether to scrape the company's employees (slower) - - Returns: - Dict[str, Any]: Structured data from the company's profile - """ - driver = get_or_create_driver() - - try: - print(f"đŸĸ Scraping company: {linkedin_url}") - if get_employees: - print("⚠ī¸ Fetching employees may take a while...") - - company = Company( - linkedin_url, - driver=driver, - get_employees=get_employees, - close_on_complete=False, - ) - - # Convert showcase pages to structured dictionaries - showcase_pages: List[Dict[str, Any]] = [ - { - "name": page.name, - "linkedin_url": page.linkedin_url, - "followers": page.followers, - } - for page in company.showcase_pages - ] - - # Convert affiliated companies to structured dictionaries - affiliated_companies: List[Dict[str, Any]] = [ - { - "name": affiliated.name, - "linkedin_url": affiliated.linkedin_url, - "followers": affiliated.followers, - } - for affiliated in company.affiliated_companies - ] - - # Build the result dictionary - result: Dict[str, Any] = { - "name": company.name, - "about_us": company.about_us, - "website": company.website, - "phone": company.phone, - "headquarters": company.headquarters, - "founded": company.founded, - "industry": company.industry, - "company_type": company.company_type, - "company_size": company.company_size, - "specialties": company.specialties, - "showcase_pages": showcase_pages, - "affiliated_companies": affiliated_companies, - "headcount": company.headcount, - } - - # Add employees if requested and available - if get_employees and company.employees: - result["employees"] = company.employees - - return result - except Exception as e: - print(f"❌ Error scraping company: {e}") - return {"error": f"Failed to scrape company profile: {str(e)}"} diff --git a/src/linkedin_mcp_server/tools/job.py b/src/linkedin_mcp_server/tools/job.py deleted file mode 100644 index 9df4e3aa..00000000 --- a/src/linkedin_mcp_server/tools/job.py +++ /dev/null @@ -1,96 +0,0 @@ -# src/linkedin_mcp_server/tools/job.py -""" -Job-related tools for LinkedIn MCP server. - -This module provides tools for scraping LinkedIn job postings and searches. -""" - -from typing import Dict, Any, List -from mcp.server.fastmcp import FastMCP -from linkedin_scraper import Job, JobSearch - -from linkedin_mcp_server.drivers.chrome import get_or_create_driver - - -def register_job_tools(mcp: FastMCP) -> None: - """ - Register all job-related tools with the MCP server. - - Args: - mcp (FastMCP): The MCP server instance - """ - - @mcp.tool() - async def get_job_details(job_url: str) -> Dict[str, Any]: - """ - Scrape job details from a LinkedIn job posting. - - Args: - job_url (str): The LinkedIn URL of the job posting - - Returns: - Dict[str, Any]: Structured data from the job posting - """ - driver = get_or_create_driver() - - try: - print(f"đŸ’ŧ Scraping job: {job_url}") - job = Job(job_url, driver=driver, close_on_complete=False) - - # Convert job object to a dictionary - return job.to_dict() - except Exception as e: - print(f"❌ Error scraping job: {e}") - return {"error": f"Failed to scrape job posting: {str(e)}"} - - @mcp.tool() - async def search_jobs(search_term: str) -> List[Dict[str, Any]]: - """ - Search for jobs on LinkedIn with the given search term. - - Args: - search_term (str): The job search query - - Returns: - List[Dict[str, Any]]: List of job search results - """ - driver = get_or_create_driver() - - try: - print(f"🔍 Searching jobs: {search_term}") - job_search = JobSearch(driver=driver, close_on_complete=False, scrape=False) - jobs = job_search.search(search_term) - - # Convert job objects to dictionaries - return [job.to_dict() for job in jobs] - except Exception as e: - print(f"❌ Error searching jobs: {e}") - return [{"error": f"Failed to search jobs: {str(e)}"}] - - @mcp.tool() - async def get_recommended_jobs() -> List[Dict[str, Any]]: - """ - Get recommended jobs from your LinkedIn homepage. - - Returns: - List[Dict[str, Any]]: List of recommended jobs - """ - driver = get_or_create_driver() - - try: - print("📋 Getting recommended jobs") - job_search = JobSearch( - driver=driver, - close_on_complete=False, - scrape=True, - scrape_recommended_jobs=True, - ) - - # Get recommended jobs and convert to dictionaries - if hasattr(job_search, "recommended_jobs"): - return [job.to_dict() for job in job_search.recommended_jobs] - else: - return [] - except Exception as e: - print(f"❌ Error getting recommended jobs: {e}") - return [{"error": f"Failed to get recommended jobs: {str(e)}"}] diff --git a/src/linkedin_mcp_server/tools/person.py b/src/linkedin_mcp_server/tools/person.py deleted file mode 100644 index 70957c93..00000000 --- a/src/linkedin_mcp_server/tools/person.py +++ /dev/null @@ -1,100 +0,0 @@ -# src/linkedin_mcp_server/tools/person.py -""" -Person profile tools for LinkedIn MCP server. - -This module provides tools for scraping LinkedIn person profiles. -""" - -from typing import Dict, Any, List -from mcp.server.fastmcp import FastMCP -from linkedin_scraper import Person - -from linkedin_mcp_server.drivers.chrome import get_or_create_driver - - -def register_person_tools(mcp: FastMCP) -> None: - """ - Register all person-related tools with the MCP server. - - Args: - mcp (FastMCP): The MCP server instance - """ - - @mcp.tool() - async def get_person_profile(linkedin_url: str) -> Dict[str, Any]: - """ - Scrape a person's LinkedIn profile. - - Args: - linkedin_url (str): The LinkedIn URL of the person's profile - - Returns: - Dict[str, Any]: Structured data from the person's profile - """ - driver = get_or_create_driver() - - try: - print(f"🔍 Scraping profile: {linkedin_url}") - person = Person(linkedin_url, driver=driver, close_on_complete=False) - - # Convert experiences to structured dictionaries - experiences: List[Dict[str, Any]] = [ - { - "position_title": exp.position_title, - "company": exp.institution_name, - "from_date": exp.from_date, - "to_date": exp.to_date, - "duration": exp.duration, - "location": exp.location, - "description": exp.description, - } - for exp in person.experiences - ] - - # Convert educations to structured dictionaries - educations: List[Dict[str, Any]] = [ - { - "institution": edu.institution_name, - "degree": edu.degree, - "from_date": edu.from_date, - "to_date": edu.to_date, - "description": edu.description, - } - for edu in person.educations - ] - - # Convert interests to list of titles - interests: List[str] = [interest.title for interest in person.interests] - - # Convert accomplishments to structured dictionaries - accomplishments: List[Dict[str, str]] = [ - {"category": acc.category, "title": acc.title} - for acc in person.accomplishments - ] - - # Convert contacts to structured dictionaries - contacts: List[Dict[str, str]] = [ - { - "name": contact.name, - "occupation": contact.occupation, - "url": contact.url, - } - for contact in person.contacts - ] - - # Return the complete profile data - return { - "name": person.name, - "about": person.about, - "experiences": experiences, - "educations": educations, - "interests": interests, - "accomplishments": accomplishments, - "contacts": contacts, - "company": person.company, - "job_title": person.job_title, - "open_to_work": getattr(person, "open_to_work", False), - } - except Exception as e: - print(f"❌ Error scraping profile: {e}") - return {"error": f"Failed to scrape profile: {str(e)}"} diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..a3845335 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,92 @@ +import pytest + + +@pytest.fixture(autouse=True) +def reset_singletons(): + """Reset global state for test isolation.""" + from linkedin_mcp_server.config import reset_config + from linkedin_mcp_server.drivers.browser import reset_browser_for_testing + + reset_browser_for_testing() + reset_config() + yield + reset_browser_for_testing() + reset_config() + + +@pytest.fixture(autouse=True) +def isolate_profile_dir(tmp_path, monkeypatch): + """Redirect profile directory to tmp_path via config and DEFAULT_PROFILE_DIR.""" + fake_profile = tmp_path / "profile" + monkeypatch.setenv("USER_DATA_DIR", str(fake_profile)) + + # Patch DEFAULT_PROFILE_DIR for any code still referencing the constant + for module in [ + "linkedin_mcp_server.drivers.browser", + "linkedin_mcp_server.authentication", + "linkedin_mcp_server.cli_main", + "linkedin_mcp_server.setup", + "linkedin_mcp_server.session_state", + ]: + try: + monkeypatch.setattr(f"{module}.DEFAULT_PROFILE_DIR", fake_profile) + except AttributeError: + pass # Module may not be imported yet + + # Patch get_profile_dir() in all modules that import it + for gp_module in [ + "linkedin_mcp_server.drivers.browser", + "linkedin_mcp_server.authentication", + "linkedin_mcp_server.cli_main", + "linkedin_mcp_server.setup", + ]: + try: + monkeypatch.setattr(f"{gp_module}.get_profile_dir", lambda: fake_profile) + except AttributeError: + pass + + try: + monkeypatch.setattr( + "linkedin_mcp_server.session_state.get_source_profile_dir", + lambda: fake_profile, + ) + except AttributeError: + pass + + for source_module in [ + "linkedin_mcp_server.authentication", + "linkedin_mcp_server.drivers.browser", + "linkedin_mcp_server.debug_trace", + "linkedin_mcp_server.error_diagnostics", + ]: + try: + monkeypatch.setattr( + f"{source_module}.get_source_profile_dir", + lambda: fake_profile, + ) + except AttributeError: + pass + + return fake_profile + + +@pytest.fixture +def profile_dir(isolate_profile_dir): + """Create a non-empty profile directory.""" + isolate_profile_dir.mkdir(parents=True, exist_ok=True) + # Create a marker file so profile_exists() returns True + (isolate_profile_dir / "Default" / "Cookies").parent.mkdir( + parents=True, exist_ok=True + ) + (isolate_profile_dir / "Default" / "Cookies").write_text("placeholder") + return isolate_profile_dir + + +@pytest.fixture +def mock_context(): + """Mock FastMCP Context.""" + from unittest.mock import AsyncMock, MagicMock + + ctx = MagicMock() + ctx.report_progress = AsyncMock() + return ctx diff --git a/tests/test_auth.py b/tests/test_auth.py new file mode 100644 index 00000000..7aa47108 --- /dev/null +++ b/tests/test_auth.py @@ -0,0 +1,340 @@ +import time + +import pytest +from starlette.applications import Starlette +from starlette.testclient import TestClient + +from linkedin_mcp_server.auth import PasswordOAuthProvider + + +@pytest.fixture +def provider(): + return PasswordOAuthProvider( + base_url="http://localhost:8000", + password="test-secret", + ) + + +class TestPasswordOAuthProvider: + def test_init_stores_password(self, provider): + assert provider._password == "test-secret" + + async def test_authorize_returns_login_url(self, provider): + from mcp.server.auth.provider import AuthorizationParams + from mcp.shared.auth import OAuthClientInformationFull + from pydantic import AnyUrl + + client_info = OAuthClientInformationFull( + client_id="test-client", + client_name="Test", + redirect_uris=[AnyUrl("https://claude.ai/api/mcp/auth_callback")], + grant_types=["authorization_code"], + response_types=["code"], + token_endpoint_auth_method="none", + ) + provider.clients["test-client"] = client_info + + params = AuthorizationParams( + state="test-state", + scopes=[], + code_challenge="test-challenge", + redirect_uri=AnyUrl("https://claude.ai/api/mcp/auth_callback"), + redirect_uri_provided_explicitly=True, + ) + + result = await provider.authorize(client_info, params) + assert "/login?" in result + assert "request_id=" in result + + async def test_authorize_stores_pending_request(self, provider): + from mcp.server.auth.provider import AuthorizationParams + from mcp.shared.auth import OAuthClientInformationFull + from pydantic import AnyUrl + + client_info = OAuthClientInformationFull( + client_id="test-client", + client_name="Test", + redirect_uris=[AnyUrl("https://example.com/callback")], + grant_types=["authorization_code"], + response_types=["code"], + token_endpoint_auth_method="none", + ) + provider.clients["test-client"] = client_info + + params = AuthorizationParams( + state="s", + scopes=[], + code_challenge="c", + redirect_uri=AnyUrl("https://example.com/callback"), + redirect_uri_provided_explicitly=True, + ) + + await provider.authorize(client_info, params) + assert len(provider._pending_auth_requests) == 1 + + +class TestLoginRoutes: + @pytest.fixture + def app(self, provider): + routes = provider.get_login_routes() + return Starlette(routes=routes) + + @pytest.fixture + def client(self, app): + return TestClient(app) + + def test_get_login_renders_form(self, client, provider): + provider._pending_auth_requests["req123"] = { + "client_id": "test", + "params": None, + "created_at": time.time(), + } + + response = client.get("/login?request_id=req123") + assert response.status_code == 200 + assert "password" in response.text + assert "req123" in response.text + + def test_get_login_invalid_request_id(self, client): + response = client.get("/login?request_id=nonexistent") + assert response.status_code == 400 + + def test_get_login_missing_request_id(self, client): + response = client.get("/login") + assert response.status_code == 400 + + def test_login_page_has_security_headers(self, client, provider): + provider._pending_auth_requests["req-hdr"] = { + "client_id": "test", + "params": None, + "created_at": time.time(), + } + response = client.get("/login?request_id=req-hdr") + assert response.headers["X-Frame-Options"] == "DENY" + assert "frame-ancestors 'none'" in response.headers["Content-Security-Policy"] + assert response.headers["X-Content-Type-Options"] == "nosniff" + + def test_post_login_correct_password(self, client, provider): + from mcp.server.auth.provider import AuthorizationParams + from mcp.shared.auth import OAuthClientInformationFull + from pydantic import AnyUrl + + params = AuthorizationParams( + state="test-state", + scopes=[], + code_challenge="test-challenge", + redirect_uri=AnyUrl("https://example.com/callback"), + redirect_uri_provided_explicitly=True, + ) + provider._pending_auth_requests["req123"] = { + "client_id": "test-client", + "params": params, + "created_at": time.time(), + } + provider.clients["test-client"] = OAuthClientInformationFull( + client_id="test-client", + client_name="Test", + redirect_uris=[AnyUrl("https://example.com/callback")], + grant_types=["authorization_code"], + response_types=["code"], + token_endpoint_auth_method="none", + ) + + response = client.post( + "/login", + data={"request_id": "req123", "password": "test-secret"}, + follow_redirects=False, + ) + assert response.status_code == 302 + assert "code=" in response.headers["location"] + assert "state=test-state" in response.headers["location"] + # Pending request consumed + assert "req123" not in provider._pending_auth_requests + + def test_post_login_wrong_password(self, client, provider): + from mcp.server.auth.provider import AuthorizationParams + from pydantic import AnyUrl + + params = AuthorizationParams( + state="s", + scopes=[], + code_challenge="c", + redirect_uri=AnyUrl("https://example.com/callback"), + redirect_uri_provided_explicitly=True, + ) + provider._pending_auth_requests["req123"] = { + "client_id": "test-client", + "params": params, + "created_at": time.time(), + } + + response = client.post( + "/login", + data={"request_id": "req123", "password": "wrong"}, + follow_redirects=False, + ) + assert response.status_code == 200 + assert "invalid" in response.text.lower() + assert "4 attempt(s) remaining" in response.text + # Pending request NOT consumed + assert "req123" in provider._pending_auth_requests + + def test_get_login_expired_request_rejected(self, client, provider): + provider._pending_auth_requests["req-expired-get"] = { + "client_id": "test-client", + "params": None, + "created_at": time.time() - 700, # 11+ minutes ago + } + + response = client.get("/login?request_id=req-expired-get") + assert response.status_code == 400 + assert "expired" in response.text.lower() + assert "req-expired-get" not in provider._pending_auth_requests + + def test_post_login_expired_request_rejected(self, client, provider): + from mcp.server.auth.provider import AuthorizationParams + from pydantic import AnyUrl + + params = AuthorizationParams( + state="s", + scopes=[], + code_challenge="c", + redirect_uri=AnyUrl("https://example.com/callback"), + redirect_uri_provided_explicitly=True, + ) + provider._pending_auth_requests["req-expired"] = { + "client_id": "test-client", + "params": params, + "created_at": time.time() - 700, # 11+ minutes ago + } + + response = client.post( + "/login", + data={"request_id": "req-expired", "password": "test-secret"}, + follow_redirects=False, + ) + assert response.status_code == 400 + assert "expired" in response.text.lower() + assert "req-expired" not in provider._pending_auth_requests + + def test_post_login_global_rate_limit(self, client, provider): + from mcp.server.auth.provider import AuthorizationParams + from pydantic import AnyUrl + + params = AuthorizationParams( + state="s", + scopes=[], + code_challenge="c", + redirect_uri=AnyUrl("https://example.com/callback"), + redirect_uri_provided_explicitly=True, + ) + + # Simulate 20 global failures (across different request_ids) + provider._global_failed_attempts = [time.time()] * 19 + provider._pending_auth_requests["req-global"] = { + "client_id": "test-client", + "params": params, + "created_at": time.time(), + } + + # This 20th failure should trigger global lockout + response = client.post( + "/login", + data={"request_id": "req-global", "password": "wrong"}, + follow_redirects=False, + ) + assert response.status_code == 429 + assert "try again later" in response.text.lower() + assert "restart" in response.text.lower() + + # Subsequent attempts also blocked even with new request_id + provider._pending_auth_requests["req-blocked"] = { + "client_id": "test-client", + "params": params, + "created_at": time.time(), + } + response = client.post( + "/login", + data={"request_id": "req-blocked", "password": "test-secret"}, + follow_redirects=False, + ) + assert response.status_code == 429 + + def test_post_login_lockout_after_max_attempts(self, client, provider): + from mcp.server.auth.provider import AuthorizationParams + from pydantic import AnyUrl + + params = AuthorizationParams( + state="s", + scopes=[], + code_challenge="c", + redirect_uri=AnyUrl("https://example.com/callback"), + redirect_uri_provided_explicitly=True, + ) + provider._pending_auth_requests["req-lock"] = { + "client_id": "test-client", + "params": params, + "created_at": time.time(), + } + + # Exhaust all 5 attempts + for i in range(5): + response = client.post( + "/login", + data={"request_id": "req-lock", "password": "wrong"}, + follow_redirects=False, + ) + + assert response.status_code == 403 + assert "too many" in response.text.lower() + # Request invalidated + assert "req-lock" not in provider._pending_auth_requests + + +class TestOAuthIntegration: + """Integration tests verifying OAuth through the HTTP layer.""" + + @pytest.fixture + def oauth_mcp(self, provider): + from fastmcp import FastMCP + + mcp = FastMCP("test-oauth", auth=provider) + + @mcp.tool + async def echo(message: str) -> dict: + return {"echo": message} + + return mcp + + @pytest.fixture + def http_client(self, oauth_mcp): + app = oauth_mcp.http_app(transport="streamable-http") + return TestClient(app) + + def test_unauthenticated_request_returns_401(self, http_client): + response = http_client.post( + "/mcp", + json={"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}, + headers={"Accept": "application/json, text/event-stream"}, + ) + assert response.status_code == 401 + assert "WWW-Authenticate" in response.headers + + def test_well_known_oauth_metadata_accessible(self, http_client): + response = http_client.get("/.well-known/oauth-authorization-server") + assert response.status_code == 200 + data = response.json() + assert "authorization_endpoint" in data + assert "token_endpoint" in data + assert "registration_endpoint" in data + + def test_login_page_accessible_without_auth(self, http_client, provider): + """Login page should be reachable without a bearer token.""" + provider._pending_auth_requests["int-req"] = { + "client_id": "test", + "params": None, + "created_at": time.time(), + } + response = http_client.get("/login?request_id=int-req") + assert response.status_code == 200 + assert "password" in response.text diff --git a/tests/test_authentication.py b/tests/test_authentication.py new file mode 100644 index 00000000..11798c7b --- /dev/null +++ b/tests/test_authentication.py @@ -0,0 +1,110 @@ +import json + +import pytest + +from linkedin_mcp_server.authentication import ( + clear_auth_state, + clear_profile, + get_authentication_source, +) +from linkedin_mcp_server.drivers.browser import profile_exists +from linkedin_mcp_server.exceptions import CredentialsNotFoundError +from linkedin_mcp_server.session_state import ( + portable_cookie_path, + runtime_profile_dir, + runtime_storage_state_path, + runtime_state_path, + source_state_path, +) + + +def _write_source_metadata(profile_dir, *, runtime_id="macos-arm64-host"): + portable_cookie_path(profile_dir).write_text( + json.dumps([{"name": "li_at", "domain": ".linkedin.com"}]) + ) + source_state_path(profile_dir).write_text( + json.dumps( + { + "version": 1, + "source_runtime_id": runtime_id, + "login_generation": "gen-1", + "created_at": "2026-03-12T17:00:00Z", + "profile_path": str(profile_dir), + "cookies_path": str(portable_cookie_path(profile_dir)), + } + ) + ) + + +def test_profile_exists_missing_dir(tmp_path): + assert profile_exists(tmp_path / "nonexistent") is False + + +def test_profile_exists_empty_dir(tmp_path): + empty = tmp_path / "empty" + empty.mkdir() + assert profile_exists(empty) is False + + +def test_profile_exists_non_empty_dir(profile_dir): + assert profile_exists(profile_dir) is True + + +def test_profile_exists_file_path(tmp_path): + file_path = tmp_path / "not_a_dir" + file_path.write_text("data") + assert profile_exists(file_path) is False + + +def test_get_authentication_source_requires_metadata(profile_dir): + with pytest.raises(CredentialsNotFoundError, match="source session metadata"): + get_authentication_source() + + +def test_get_authentication_source_accepts_source_session(profile_dir): + _write_source_metadata(profile_dir) + assert get_authentication_source() is True + + +def test_get_authentication_source_none_raises(isolate_profile_dir): + with pytest.raises(CredentialsNotFoundError): + get_authentication_source() + + +def test_clear_profile_removes_dir(profile_dir): + assert profile_dir.exists() + result = clear_profile(profile_dir) + assert result is True + assert not profile_dir.exists() + + +def test_clear_auth_state_removes_source_and_runtime_files(profile_dir): + _write_source_metadata(profile_dir) + runtime_profile = runtime_profile_dir("linux-amd64-container", profile_dir) + runtime_profile.mkdir(parents=True) + storage_state_path = runtime_storage_state_path( + "linux-amd64-container", profile_dir + ) + storage_state_path.parent.mkdir(parents=True, exist_ok=True) + storage_state_path.write_text("{}") + runtime_state_path("linux-amd64-container", profile_dir).write_text( + json.dumps( + { + "version": 1, + "runtime_id": "linux-amd64-container", + "source_runtime_id": "macos-arm64-host", + "source_login_generation": "gen-1", + "created_at": "2026-03-12T17:10:00Z", + "committed_at": "2026-03-12T17:10:05Z", + "profile_path": str(runtime_profile), + "storage_state_path": str(storage_state_path), + "commit_method": "checkpoint_restart", + } + ) + ) + + assert clear_auth_state(profile_dir) is True + assert not profile_dir.exists() + assert not portable_cookie_path(profile_dir).exists() + assert not source_state_path(profile_dir).exists() + assert not runtime_profile_dir("linux-amd64-container", profile_dir).exists() diff --git a/tests/test_browser_driver.py b/tests/test_browser_driver.py new file mode 100644 index 00000000..9b12c92e --- /dev/null +++ b/tests/test_browser_driver.py @@ -0,0 +1,738 @@ +"""Tests for linkedin_mcp_server.drivers.browser runtime-aware auth startup.""" + +import json +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + +from linkedin_mcp_server.config.schema import AppConfig +from linkedin_mcp_server.drivers.browser import ( + _feed_auth_succeeds, + get_or_create_browser, + reset_browser_for_testing, +) +from linkedin_mcp_server.session_state import ( + portable_cookie_path, + runtime_profile_dir, + runtime_state_path, + runtime_storage_state_path, + source_state_path, +) + + +@pytest.fixture(autouse=True) +def _reset_browser(): + reset_browser_for_testing() + yield + reset_browser_for_testing() + + +@pytest.fixture(autouse=True) +def _mock_config(monkeypatch, tmp_path): + config = AppConfig() + config.browser.user_data_dir = str(tmp_path / "profile") + monkeypatch.setattr( + "linkedin_mcp_server.drivers.browser.get_config", lambda: config + ) + + +def _make_mock_browser() -> MagicMock: + browser = MagicMock() + browser.start = AsyncMock() + browser.close = AsyncMock() + browser.page = MagicMock() + browser.page.url = "https://www.linkedin.com/feed/" + browser.page.goto = AsyncMock() + browser.page.set_default_timeout = MagicMock() + browser.page.title = AsyncMock(return_value="LinkedIn") + browser.page.evaluate = AsyncMock(return_value="Feed") + locator = MagicMock() + locator.count = AsyncMock(return_value=0) + browser.page.locator = MagicMock(return_value=locator) + browser.import_cookies = AsyncMock(return_value=False) + browser.export_cookies = AsyncMock(return_value=False) + browser.export_storage_state = AsyncMock(return_value=True) + return browser + + +def _write_source_state(tmp_path, *, runtime_id: str, login_generation: str = "gen-1"): + profile_dir = tmp_path / "profile" + profile_dir.mkdir(parents=True, exist_ok=True) + (profile_dir / "Default").mkdir(parents=True, exist_ok=True) + (profile_dir / "Default" / "Cookies").write_text("placeholder") + portable_cookie_path(profile_dir).write_text( + json.dumps([{"name": "li_at", "domain": ".linkedin.com"}]) + ) + source_state_path(profile_dir).write_text( + json.dumps( + { + "version": 1, + "source_runtime_id": runtime_id, + "login_generation": login_generation, + "created_at": "2026-03-12T17:00:00Z", + "profile_path": str(profile_dir), + "cookies_path": str(portable_cookie_path(profile_dir)), + } + ) + ) + return profile_dir + + +def _write_runtime_state( + tmp_path, + runtime_id: str, + *, + source_runtime_id: str = "macos-arm64-host", + source_login_generation: str = "gen-1", + with_storage_state: bool = True, +): + profile_dir = runtime_profile_dir(runtime_id, tmp_path / "profile") + profile_dir.mkdir(parents=True, exist_ok=True) + (profile_dir / "Default").mkdir(parents=True, exist_ok=True) + (profile_dir / "Default" / "Cookies").write_text("placeholder") + storage_state_path = runtime_storage_state_path(runtime_id, tmp_path / "profile") + if with_storage_state: + storage_state_path.parent.mkdir(parents=True, exist_ok=True) + storage_state_path.write_text("{}") + runtime_state_path(runtime_id, tmp_path / "profile").write_text( + json.dumps( + { + "version": 1, + "runtime_id": runtime_id, + "source_runtime_id": source_runtime_id, + "source_login_generation": source_login_generation, + "created_at": "2026-03-12T17:10:00Z", + "committed_at": "2026-03-12T17:10:05Z", + "profile_path": str(profile_dir), + "storage_state_path": str(storage_state_path), + "commit_method": "checkpoint_restart", + } + ) + ) + return profile_dir + + +@pytest.mark.asyncio +async def test_get_or_create_browser_requires_source_state(): + from linkedin_mcp_server.core import AuthenticationError + + with pytest.raises(AuthenticationError): + await get_or_create_browser() + + +@pytest.mark.asyncio +async def test_same_runtime_uses_source_profile(tmp_path): + _write_source_state(tmp_path, runtime_id="macos-arm64-host") + source_browser = _make_mock_browser() + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="macos-arm64-host", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=source_browser, + ) as ctor, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + assert result is source_browser + ctor.assert_called_once() + assert ctor.call_args.kwargs["user_data_dir"] == tmp_path / "profile" + source_browser.import_cookies.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_same_runtime_clicks_remember_me_during_feed_validation(tmp_path): + _write_source_state(tmp_path, runtime_id="macos-arm64-host") + source_browser = _make_mock_browser() + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="macos-arm64-host", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=source_browser, + ), + patch( + "linkedin_mcp_server.drivers.browser.resolve_remember_me_prompt", + new_callable=AsyncMock, + return_value=True, + ) as remember_me, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + assert result is source_browser + assert source_browser.page.goto.await_count == 2 + assert remember_me.await_count == 1 + + +@pytest.mark.asyncio +async def test_feed_auth_retries_feed_after_remember_me_error_recovery(): + browser = _make_mock_browser() + browser.page.goto = AsyncMock( + side_effect=[Exception("net::ERR_TOO_MANY_REDIRECTS"), None] + ) + + with ( + patch( + "linkedin_mcp_server.drivers.browser.resolve_remember_me_prompt", + new_callable=AsyncMock, + return_value=True, + ) as remember_me, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + assert await _feed_auth_succeeds(browser) is True + + assert browser.page.goto.await_count == 2 + remember_me.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_feed_auth_records_single_post_recovery_trace(): + browser = _make_mock_browser() + browser.page.goto = AsyncMock( + side_effect=[Exception("net::ERR_TOO_MANY_REDIRECTS"), None] + ) + + with ( + patch( + "linkedin_mcp_server.drivers.browser.resolve_remember_me_prompt", + new_callable=AsyncMock, + return_value=True, + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.drivers.browser.record_page_trace", + new_callable=AsyncMock, + ) as record_page_trace, + ): + assert await _feed_auth_succeeds(browser) is True + + steps = [call.args[1] for call in record_page_trace.await_args_list] + assert "feed-after-remember-me-error-recovery" in steps + assert "feed-navigation-error-before-remember-me-retry" not in steps + + +@pytest.mark.asyncio +async def test_experimental_derived_runtime_reuses_matching_committed_profile( + tmp_path, monkeypatch +): + _write_source_state(tmp_path, runtime_id="macos-arm64-host") + derived_profile = _write_runtime_state(tmp_path, "linux-amd64-container") + derived_browser = _make_mock_browser() + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=derived_browser, + ) as ctor, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + assert result is derived_browser + assert ctor.call_args.kwargs["user_data_dir"] == derived_profile + derived_browser.import_cookies.assert_not_awaited() + derived_browser.export_storage_state.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_default_foreign_runtime_bridges_fresh_each_startup(tmp_path): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + _write_runtime_state( + tmp_path, + "linux-amd64-container", + source_login_generation="gen-2", + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=first_browser, + ) as ctor, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + expected_profile = runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ) + assert result is first_browser + assert ctor.call_count == 1 + assert ctor.call_args.kwargs["user_data_dir"] == expected_profile + first_browser.import_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + first_browser.export_storage_state.assert_not_awaited() + first_browser.close.assert_not_awaited() + assert not runtime_state_path( + "linux-amd64-container", tmp_path / "profile" + ).exists() + + +@pytest.mark.asyncio +async def test_experimental_missing_derived_runtime_bridges_and_checkpoint_commits( + tmp_path, monkeypatch +): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + reopened_browser = _make_mock_browser() + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + side_effect=[first_browser, reopened_browser], + ) as ctor, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + expected_profile = runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ) + expected_storage = runtime_storage_state_path( + "linux-amd64-container", tmp_path / "profile" + ) + assert result is reopened_browser + assert ctor.call_count == 2 + assert ctor.call_args_list[0].kwargs["user_data_dir"] == expected_profile + assert ctor.call_args_list[1].kwargs["user_data_dir"] == expected_profile + first_browser.import_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + first_browser.export_storage_state.assert_awaited_once_with( + expected_storage, + indexed_db=True, + ) + first_browser.close.assert_awaited_once() + runtime_state = json.loads( + runtime_state_path("linux-amd64-container", tmp_path / "profile").read_text() + ) + assert runtime_state["source_login_generation"] == "gen-2" + assert runtime_state["storage_state_path"] == str(expected_storage.resolve()) + + +@pytest.mark.asyncio +async def test_debug_skip_checkpoint_restart_keeps_fresh_bridged_browser( + tmp_path, monkeypatch +): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + monkeypatch.setenv("LINKEDIN_DEBUG_SKIP_CHECKPOINT_RESTART", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=first_browser, + ) as ctor, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + assert result is first_browser + assert ctor.call_count == 1 + first_browser.import_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + first_browser.export_storage_state.assert_not_awaited() + first_browser.close.assert_not_awaited() + assert not runtime_state_path( + "linux-amd64-container", tmp_path / "profile" + ).exists() + + +@pytest.mark.asyncio +async def test_debug_bridge_every_startup_skips_matching_committed_profile( + tmp_path, monkeypatch +): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + _write_runtime_state( + tmp_path, + "linux-amd64-container", + source_login_generation="gen-2", + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + monkeypatch.setenv("LINKEDIN_DEBUG_BRIDGE_EVERY_STARTUP", "1") + monkeypatch.setenv("LINKEDIN_DEBUG_SKIP_CHECKPOINT_RESTART", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=first_browser, + ) as ctor, + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + result = await get_or_create_browser() + + expected_profile = runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ) + assert result is first_browser + assert ctor.call_count == 1 + assert ctor.call_args.kwargs["user_data_dir"] == expected_profile + first_browser.import_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + first_browser.export_storage_state.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_debug_bridge_cookie_set_flows_through_foreign_runtime_bridge( + tmp_path, monkeypatch +): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + monkeypatch.setenv("LINKEDIN_DEBUG_BRIDGE_COOKIE_SET", "bridge_core") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=first_browser, + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + await get_or_create_browser() + + first_browser.import_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + + +@pytest.mark.asyncio +async def test_experimental_stale_derived_runtime_rebuilds_from_new_generation( + tmp_path, monkeypatch +): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-3" + ) + stale_profile = _write_runtime_state( + tmp_path, + "linux-amd64-container", + source_login_generation="old-gen", + ) + old_marker = stale_profile / "stale.txt" + old_marker.write_text("stale") + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + reopened_browser = _make_mock_browser() + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + side_effect=[first_browser, reopened_browser], + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + await get_or_create_browser() + + assert not old_marker.exists() + runtime_state = json.loads( + runtime_state_path("linux-amd64-container", tmp_path / "profile").read_text() + ) + assert runtime_state["source_login_generation"] == "gen-3" + + +@pytest.mark.asyncio +async def test_experimental_matching_derived_runtime_failure_rebridges_from_source( + tmp_path, monkeypatch +): + _write_source_state(tmp_path, runtime_id="macos-arm64-host") + _write_runtime_state(tmp_path, "linux-amd64-container") + invalid_browser = _make_mock_browser() + bridged_browser = _make_mock_browser() + bridged_browser.import_cookies = AsyncMock(return_value=True) + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + monkeypatch.setenv("LINKEDIN_DEBUG_SKIP_CHECKPOINT_RESTART", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + side_effect=[invalid_browser, bridged_browser], + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + side_effect=["login title: linkedin login", None], + ), + ): + result = await get_or_create_browser() + + assert result is bridged_browser + invalid_browser.close.assert_awaited_once() + invalid_browser.import_cookies.assert_not_awaited() + bridged_browser.import_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + + +@pytest.mark.asyncio +async def test_same_runtime_start_failure_closes_browser(tmp_path): + _write_source_state(tmp_path, runtime_id="macos-arm64-host") + source_browser = _make_mock_browser() + source_browser.start = AsyncMock(side_effect=RuntimeError("start failed")) + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="macos-arm64-host", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=source_browser, + ), + pytest.raises(RuntimeError, match="start failed"), + ): + await get_or_create_browser() + + source_browser.close.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_default_foreign_runtime_start_failure_closes_browser(tmp_path): + _write_source_state(tmp_path, runtime_id="macos-arm64-host") + first_browser = _make_mock_browser() + first_browser.start = AsyncMock(side_effect=RuntimeError("start failed")) + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=first_browser, + ), + pytest.raises(RuntimeError, match="start failed"), + ): + await get_or_create_browser() + + first_browser.close.assert_awaited_once() + assert not runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ).exists() + assert not runtime_state_path( + "linux-amd64-container", tmp_path / "profile" + ).exists() + + +@pytest.mark.asyncio +async def test_experimental_checkpoint_reopen_failure_clears_runtime_dir( + tmp_path, monkeypatch +): + from linkedin_mcp_server.core import AuthenticationError + + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + reopened_browser = _make_mock_browser() + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + + barrier_mock = AsyncMock(side_effect=[None, "checkpoint"]) + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + side_effect=[first_browser, reopened_browser], + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + barrier_mock, + ), + pytest.raises(AuthenticationError), + ): + await get_or_create_browser() + + assert not runtime_state_path( + "linux-amd64-container", tmp_path / "profile" + ).exists() + assert not runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ).exists() + reopened_browser.close.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_experimental_reopen_start_failure_closes_reopened_browser( + tmp_path, monkeypatch +): + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + reopened_browser = _make_mock_browser() + reopened_browser.start = AsyncMock(side_effect=RuntimeError("reopen failed")) + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + side_effect=[first_browser, reopened_browser], + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + pytest.raises(RuntimeError, match="reopen failed"), + ): + await get_or_create_browser() + + reopened_browser.close.assert_awaited_once() + assert not runtime_state_path( + "linux-amd64-container", tmp_path / "profile" + ).exists() + assert not runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ).exists() + + +@pytest.mark.asyncio +async def test_experimental_bridge_validation_failure_before_commit_clears_runtime_dir( + tmp_path, monkeypatch +): + from linkedin_mcp_server.core import AuthenticationError + + _write_source_state( + tmp_path, runtime_id="macos-arm64-host", login_generation="gen-2" + ) + first_browser = _make_mock_browser() + first_browser.import_cookies = AsyncMock(return_value=True) + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + + barrier_mock = AsyncMock(return_value="login title: linkedin login") + with ( + patch( + "linkedin_mcp_server.drivers.browser.get_runtime_id", + return_value="linux-amd64-container", + ), + patch( + "linkedin_mcp_server.drivers.browser.BrowserManager", + return_value=first_browser, + ), + patch( + "linkedin_mcp_server.drivers.browser.detect_auth_barrier_quick", + barrier_mock, + ), + pytest.raises(AuthenticationError), + ): + await get_or_create_browser() + + assert not runtime_state_path( + "linux-amd64-container", tmp_path / "profile" + ).exists() + assert not runtime_profile_dir( + "linux-amd64-container", tmp_path / "profile" + ).exists() diff --git a/tests/test_cli_main.py b/tests/test_cli_main.py new file mode 100644 index 00000000..4dded60b --- /dev/null +++ b/tests/test_cli_main.py @@ -0,0 +1,340 @@ +"""Tests for CLI startup behavior and transport selection.""" + +import importlib.metadata +import json +from typing import Literal +from unittest.mock import AsyncMock, MagicMock + +import pytest + +import linkedin_mcp_server.cli_main as cli_main +from linkedin_mcp_server.config.schema import AppConfig +from linkedin_mcp_server.exceptions import CredentialsNotFoundError + + +def _make_config( + *, + is_interactive: bool, + transport: Literal["stdio", "streamable-http"], + transport_explicitly_set: bool, +) -> AppConfig: + config = AppConfig() + config.is_interactive = is_interactive + config.server.transport = transport + config.server.transport_explicitly_set = transport_explicitly_set + return config + + +def _patch_main_dependencies( + monkeypatch: pytest.MonkeyPatch, config: AppConfig +) -> None: + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_config", lambda: config) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.configure_logging", lambda **_kwargs: None + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_version", lambda: "4.0.0") + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.ensure_authentication_ready", lambda: None + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.set_headless", lambda _x: None) + + +def test_main_non_interactive_stdio_has_no_human_stdout( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + config = _make_config( + is_interactive=False, transport="stdio", transport_explicitly_set=False + ) + _patch_main_dependencies(monkeypatch, config) + mcp = MagicMock() + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.create_mcp_server", lambda **_: mcp + ) + + cli_main.main() + + mcp.run.assert_called_once_with(transport="stdio") + captured = capsys.readouterr() + assert captured.out == "" + + +def test_main_interactive_prompts_when_transport_not_explicit( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + config = _make_config( + is_interactive=True, transport="stdio", transport_explicitly_set=False + ) + _patch_main_dependencies(monkeypatch, config) + choose_transport = MagicMock(return_value="streamable-http") + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.choose_transport_interactive", choose_transport + ) + mcp = MagicMock() + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.create_mcp_server", lambda **_: mcp + ) + + cli_main.main() + + choose_transport.assert_called_once_with() + captured = capsys.readouterr() + assert "Server ready! Choose transport mode:" in captured.out + mcp.run.assert_called_once_with( + transport="streamable-http", + host=config.server.host, + port=config.server.port, + path=config.server.path, + ) + + +def test_main_explicit_transport_skips_prompt( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + config = _make_config( + is_interactive=True, transport="stdio", transport_explicitly_set=True + ) + _patch_main_dependencies(monkeypatch, config) + choose_transport = MagicMock(return_value="streamable-http") + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.choose_transport_interactive", choose_transport + ) + mcp = MagicMock() + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.create_mcp_server", lambda **_: mcp + ) + + cli_main.main() + + choose_transport.assert_not_called() + captured = capsys.readouterr() + assert "Server ready! Choose transport mode:" not in captured.out + mcp.run.assert_called_once_with(transport="stdio") + + +def test_main_streamable_http_passes_host_port_path( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + config = _make_config( + is_interactive=False, + transport="streamable-http", + transport_explicitly_set=True, + ) + config.server.host = "0.0.0.0" + config.server.port = 8123 + config.server.path = "/custom-mcp" + _patch_main_dependencies(monkeypatch, config) + mcp = MagicMock() + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.create_mcp_server", lambda **_: mcp + ) + + cli_main.main() + + mcp.run.assert_called_once_with( + transport="streamable-http", + host="0.0.0.0", + port=8123, + path="/custom-mcp", + ) + captured = capsys.readouterr() + assert captured.out == "" + + +def test_get_version_prefers_installed_metadata( + monkeypatch: pytest.MonkeyPatch, +) -> None: + calls: list[str] = [] + + def fake_version(package_name: str) -> str: + calls.append(package_name) + if package_name == "linkedin-scraper-mcp": + return "4.2.0" + raise importlib.metadata.PackageNotFoundError(package_name) + + monkeypatch.setattr(importlib.metadata, "version", fake_version) + + assert cli_main.get_version() == "4.2.0" + assert calls == ["linkedin-scraper-mcp"] + + +def test_main_non_interactive_auth_failure_has_no_stdout( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + config = _make_config( + is_interactive=False, transport="stdio", transport_explicitly_set=False + ) + _patch_main_dependencies(monkeypatch, config) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.ensure_authentication_ready", + lambda: (_ for _ in ()).throw(CredentialsNotFoundError("missing profile")), + ) + + with pytest.raises(SystemExit) as exit_info: + cli_main.main() + + assert exit_info.value.code == 1 + captured = capsys.readouterr() + assert captured.out == "" + + +def test_profile_info_reports_bridge_required_for_foreign_runtime( + monkeypatch: pytest.MonkeyPatch, + capsys: pytest.CaptureFixture[str], + tmp_path, +) -> None: + profile_dir = tmp_path / "profile" + profile_dir.mkdir(parents=True) + (profile_dir / "Default").mkdir(parents=True) + (profile_dir / "Default" / "Cookies").write_text("placeholder") + (tmp_path / "cookies.json").write_text(json.dumps([{"name": "li_at"}])) + (tmp_path / "source-state.json").write_text( + json.dumps( + { + "version": 1, + "source_runtime_id": "macos-arm64-host", + "login_generation": "gen-1", + "created_at": "2026-03-12T17:00:00Z", + "profile_path": str(profile_dir), + "cookies_path": str(tmp_path / "cookies.json"), + } + ) + ) + + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.get_profile_dir", lambda: profile_dir + ) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.get_runtime_id", lambda: "linux-amd64-container" + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_config", lambda: AppConfig()) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.configure_logging", lambda **_kwargs: None + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_version", lambda: "4.0.0") + + with pytest.raises(SystemExit) as exit_info: + cli_main.profile_info_and_exit() + + assert exit_info.value.code == 0 + captured = capsys.readouterr() + assert "fresh bridge each startup" in captured.out.lower() + assert "fresh bridged foreign-runtime session" in captured.out.lower() + assert "source cookie validity is not verified" in captured.out.lower() + + +def test_profile_info_reports_committed_derived_runtime( + monkeypatch: pytest.MonkeyPatch, + capsys: pytest.CaptureFixture[str], + tmp_path, +) -> None: + profile_dir = tmp_path / "profile" + profile_dir.mkdir(parents=True) + (profile_dir / "Default").mkdir(parents=True) + (profile_dir / "Default" / "Cookies").write_text("placeholder") + runtime_profile = ( + tmp_path / "runtime-profiles" / "linux-amd64-container" / "profile" + ) + runtime_profile.mkdir(parents=True) + (runtime_profile / "Default").mkdir(parents=True) + (runtime_profile / "Default" / "Cookies").write_text("placeholder") + storage_state = ( + tmp_path / "runtime-profiles" / "linux-amd64-container" / "storage-state.json" + ) + storage_state.write_text("{}") + (tmp_path / "cookies.json").write_text(json.dumps([{"name": "li_at"}])) + (tmp_path / "source-state.json").write_text( + json.dumps( + { + "version": 1, + "source_runtime_id": "macos-arm64-host", + "login_generation": "gen-1", + "created_at": "2026-03-12T17:00:00Z", + "profile_path": str(profile_dir), + "cookies_path": str(tmp_path / "cookies.json"), + } + ) + ) + ( + tmp_path / "runtime-profiles" / "linux-amd64-container" / "runtime-state.json" + ).write_text( + json.dumps( + { + "version": 1, + "runtime_id": "linux-amd64-container", + "source_runtime_id": "macos-arm64-host", + "source_login_generation": "gen-1", + "created_at": "2026-03-12T17:10:00Z", + "committed_at": "2026-03-12T17:10:05Z", + "profile_path": str(runtime_profile), + "storage_state_path": str(storage_state), + "commit_method": "checkpoint_restart", + } + ) + ) + + browser = MagicMock() + browser.is_authenticated = True + + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.get_profile_dir", lambda: profile_dir + ) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.get_runtime_id", lambda: "linux-amd64-container" + ) + monkeypatch.setenv("LINKEDIN_EXPERIMENTAL_PERSIST_DERIVED_SESSION", "1") + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_config", lambda: AppConfig()) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.configure_logging", lambda **_kwargs: None + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_version", lambda: "4.0.0") + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.get_or_create_browser", + AsyncMock(return_value=browser), + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.close_browser", AsyncMock()) + + with pytest.raises(SystemExit) as exit_info: + cli_main.profile_info_and_exit() + + assert exit_info.value.code == 0 + captured = capsys.readouterr() + assert "derived (committed, current generation)" in captured.out.lower() + assert str(storage_state) in captured.out + + +def test_clear_profile_and_exit_clears_all_auth_state( + monkeypatch: pytest.MonkeyPatch, + capsys: pytest.CaptureFixture[str], + tmp_path, +) -> None: + config = AppConfig() + config.browser.user_data_dir = str(tmp_path / "profile") + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_config", lambda: config) + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.configure_logging", lambda **_kwargs: None + ) + monkeypatch.setattr("linkedin_mcp_server.cli_main.get_version", lambda: "4.0.0") + monkeypatch.setattr( + "linkedin_mcp_server.cli_main.get_profile_dir", lambda: tmp_path / "profile" + ) + monkeypatch.setattr("builtins.input", lambda _prompt="": "y") + + profile_dir = tmp_path / "profile" + profile_dir.mkdir(parents=True) + (tmp_path / "source-state.json").write_text("{}") + + cleared = {} + + def fake_clear(profile): + cleared["profile"] = profile + return True + + monkeypatch.setattr("linkedin_mcp_server.cli_main.clear_auth_state", fake_clear) + + with pytest.raises(SystemExit) as exit_info: + cli_main.clear_profile_and_exit() + + assert exit_info.value.code == 0 + assert cleared["profile"] == profile_dir + captured = capsys.readouterr() + assert "authentication state cleared" in captured.out.lower() diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 00000000..2c1d3a5e --- /dev/null +++ b/tests/test_config.py @@ -0,0 +1,263 @@ +import pytest + +from linkedin_mcp_server.config.schema import ( + AppConfig, + BrowserConfig, + ConfigurationError, + OAuthConfig, + ServerConfig, +) + + +class TestBrowserConfig: + def test_defaults(self): + config = BrowserConfig() + assert config.headless is True + assert config.default_timeout == 5000 + assert config.user_data_dir == "~/.linkedin-mcp/profile" + + def test_validate_passes(self): + BrowserConfig().validate() # No error + + def test_validate_negative_timeout(self): + with pytest.raises(ConfigurationError): + BrowserConfig(default_timeout=-1).validate() + + def test_validate_negative_slow_mo(self): + with pytest.raises(ConfigurationError): + BrowserConfig(slow_mo=-1).validate() + + +class TestServerConfig: + def test_defaults(self): + config = ServerConfig() + assert config.transport == "stdio" + assert config.port == 8000 + + +class TestAppConfig: + def test_validate_invalid_port(self): + config = AppConfig() + config.server.port = 99999 + with pytest.raises(ConfigurationError): + config.validate() + + +class TestOAuthConfig: + def test_defaults(self): + config = OAuthConfig() + assert config.enabled is False + assert config.base_url is None + assert config.password is None + + def test_validate_requires_base_url_when_enabled(self): + config = AppConfig() + config.server.transport = "streamable-http" + config.server.oauth = OAuthConfig(enabled=True, password="secret") + with pytest.raises(ConfigurationError, match="OAUTH_BASE_URL"): + config.validate() + + def test_validate_requires_password_when_enabled(self): + config = AppConfig() + config.server.transport = "streamable-http" + config.server.oauth = OAuthConfig(enabled=True, base_url="https://example.com") + with pytest.raises(ConfigurationError, match="OAUTH_PASSWORD"): + config.validate() + + def test_validate_passes_when_fully_configured(self): + config = AppConfig() + config.server.transport = "streamable-http" + config.server.oauth = OAuthConfig( + enabled=True, base_url="https://example.com", password="secret" + ) + config.validate() # No error + + def test_validate_requires_streamable_http_transport(self): + config = AppConfig() + config.server.transport = "stdio" + config.server.oauth = OAuthConfig( + enabled=True, base_url="https://example.com", password="secret" + ) + with pytest.raises(ConfigurationError, match="streamable-http"): + config.validate() + + def test_validate_rejects_http_base_url(self): + config = AppConfig() + config.server.transport = "streamable-http" + config.server.oauth = OAuthConfig( + enabled=True, base_url="http://example.com", password="secret" + ) + with pytest.raises(ConfigurationError, match="HTTPS"): + config.validate() + + def test_validate_rejects_base_url_with_path(self): + config = AppConfig() + config.server.transport = "streamable-http" + config.server.oauth = OAuthConfig( + enabled=True, base_url="https://example.com/api", password="secret" + ) + with pytest.raises(ConfigurationError, match="path component"): + config.validate() + + def test_validate_accepts_base_url_with_trailing_slash(self): + config = AppConfig() + config.server.transport = "streamable-http" + config.server.oauth = OAuthConfig( + enabled=True, base_url="https://example.com/", password="secret" + ) + config.validate() # No error — trailing slash is fine + + def test_validate_passes_when_disabled(self): + config = AppConfig() + config.server.oauth = OAuthConfig(enabled=False) + config.validate() # No error + + @pytest.mark.parametrize("flag", ["login", "status", "logout"]) + def test_validate_skips_oauth_in_command_only_modes(self, flag): + """OAuth validation should not block --login, --status, --logout.""" + config = AppConfig() + config.server.oauth = OAuthConfig(enabled=True) # Missing base_url + password + setattr(config.server, flag, True) + config.validate() # No error — skipped for command-only modes + + +class TestConfigSingleton: + def test_get_config_returns_same_instance(self, monkeypatch): + # Mock sys.argv to prevent argparse from parsing pytest's arguments + monkeypatch.setattr("sys.argv", ["linkedin-mcp-server"]) + from linkedin_mcp_server.config import get_config + + assert get_config() is get_config() + + def test_reset_config_clears_singleton(self, monkeypatch): + # Mock sys.argv to prevent argparse from parsing pytest's arguments + monkeypatch.setattr("sys.argv", ["linkedin-mcp-server"]) + from linkedin_mcp_server.config import get_config, reset_config + + first = get_config() + reset_config() + second = get_config() + assert first is not second + + +class TestLoaders: + def test_load_from_env_headless_false(self, monkeypatch): + monkeypatch.setenv("HEADLESS", "false") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.headless is False + + def test_load_from_env_headless_true(self, monkeypatch): + monkeypatch.setenv("HEADLESS", "true") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.headless is True + + def test_load_from_env_log_level(self, monkeypatch): + monkeypatch.setenv("LOG_LEVEL", "DEBUG") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.server.log_level == "DEBUG" + + def test_load_from_env_defaults(self, monkeypatch): + # Clear env vars + for var in ["HEADLESS", "LOG_LEVEL"]: + monkeypatch.delenv(var, raising=False) + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.headless is True # default + + def test_load_from_env_transport(self, monkeypatch): + monkeypatch.setenv("TRANSPORT", "streamable-http") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.server.transport == "streamable-http" + assert config.server.transport_explicitly_set is True + + def test_load_from_env_invalid_transport(self, monkeypatch): + monkeypatch.setenv("TRANSPORT", "invalid") + from linkedin_mcp_server.config.loaders import load_from_env + + with pytest.raises(ConfigurationError, match="Invalid TRANSPORT"): + load_from_env(AppConfig()) + + def test_load_from_env_timeout(self, monkeypatch): + monkeypatch.setenv("TIMEOUT", "10000") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.default_timeout == 10000 + + def test_load_from_env_invalid_timeout(self, monkeypatch): + monkeypatch.setenv("TIMEOUT", "invalid") + from linkedin_mcp_server.config.loaders import load_from_env + + with pytest.raises(ConfigurationError, match="Invalid TIMEOUT"): + load_from_env(AppConfig()) + + def test_load_from_env_port(self, monkeypatch): + monkeypatch.setenv("PORT", "9000") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.server.port == 9000 + + def test_load_from_env_slow_mo(self, monkeypatch): + monkeypatch.setenv("SLOW_MO", "100") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.slow_mo == 100 + + def test_load_from_env_viewport(self, monkeypatch): + monkeypatch.setenv("VIEWPORT", "1920x1080") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.viewport_width == 1920 + assert config.browser.viewport_height == 1080 + + def test_load_from_env_invalid_viewport(self, monkeypatch): + monkeypatch.setenv("VIEWPORT", "invalid") + from linkedin_mcp_server.config.loaders import load_from_env + + with pytest.raises(ConfigurationError, match="Invalid VIEWPORT"): + load_from_env(AppConfig()) + + def test_load_from_env_user_data_dir(self, monkeypatch): + monkeypatch.setenv("USER_DATA_DIR", "/custom/profile") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.browser.user_data_dir == "/custom/profile" + + def test_load_from_env_oauth_enabled(self, monkeypatch): + monkeypatch.setenv("AUTH", "oauth") + monkeypatch.setenv("OAUTH_BASE_URL", "https://example.com") + monkeypatch.setenv("OAUTH_PASSWORD", "secret123") + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.server.oauth.enabled is True + assert config.server.oauth.base_url == "https://example.com" + assert config.server.oauth.password == "secret123" + + def test_load_from_env_oauth_disabled_by_default(self, monkeypatch): + for var in ["AUTH", "OAUTH_BASE_URL", "OAUTH_PASSWORD"]: + monkeypatch.delenv(var, raising=False) + from linkedin_mcp_server.config.loaders import load_from_env + + config = load_from_env(AppConfig()) + assert config.server.oauth.enabled is False + + def test_load_from_env_invalid_auth_mode(self, monkeypatch): + monkeypatch.setenv("AUTH", "invalid") + from linkedin_mcp_server.config.loaders import load_from_env + + with pytest.raises(ConfigurationError, match="Invalid AUTH"): + load_from_env(AppConfig()) diff --git a/tests/test_core_auth.py b/tests/test_core_auth.py new file mode 100644 index 00000000..017a15da --- /dev/null +++ b/tests/test_core_auth.py @@ -0,0 +1,240 @@ +"""Tests for auth barrier detection helpers.""" + +from unittest.mock import AsyncMock, MagicMock + +import pytest + +from linkedin_mcp_server.core.exceptions import AuthenticationError +from linkedin_mcp_server.core.auth import ( + detect_auth_barrier, + detect_auth_barrier_quick, + is_logged_in, + resolve_remember_me_prompt, + wait_for_manual_login, +) + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_for_account_picker(): + page = MagicMock() + page.url = "https://www.linkedin.com/login" + page.title = AsyncMock(return_value="LinkedIn Login, Sign in | LinkedIn") + page.evaluate = AsyncMock( + return_value="Welcome Back\nSign in using another account\nJoin now" + ) + + result = await detect_auth_barrier(page) + + assert result is not None + assert "auth blocker URL" in result + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_for_continue_as_account_picker(): + page = MagicMock() + page.url = "https://www.linkedin.com/checkpoint/lg/login-submit" + page.title = AsyncMock(return_value="LinkedIn Sign In") + page.evaluate = AsyncMock( + return_value="Continue as Daniel Sticker\nSign in using another account" + ) + + result = await detect_auth_barrier(page) + + assert result is not None + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_for_choose_account_picker(): + page = MagicMock() + page.url = "https://www.linkedin.com/checkpoint/lg/login-submit" + page.title = AsyncMock(return_value="LinkedIn Sign In") + page.evaluate = AsyncMock( + return_value="Choose an account\nSign in using another account" + ) + + result = await detect_auth_barrier(page) + + assert result is not None + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_returns_none_for_authenticated_page(): + page = MagicMock() + page.url = "https://www.linkedin.com/feed/" + page.title = AsyncMock(return_value="LinkedIn Feed") + page.evaluate = AsyncMock(return_value="Home\nMy Network\nJobs\nMessaging") + + result = await detect_auth_barrier(page) + + assert result is None + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_quick_skips_body_text_on_authenticated_page(): + page = MagicMock() + page.url = "https://www.linkedin.com/feed/" + page.title = AsyncMock(return_value="LinkedIn Feed") + page.evaluate = AsyncMock(return_value="Home\nMy Network\nJobs\nMessaging") + + result = await detect_auth_barrier_quick(page) + + assert result is None + page.evaluate.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_is_logged_in_rejects_empty_authenticated_only_page(): + page = MagicMock() + page.url = "https://www.linkedin.com/feed/" + page.locator.return_value.count = AsyncMock(return_value=0) + page.evaluate = AsyncMock(return_value="") + + result = await is_logged_in(page) + + assert result is False + + +@pytest.mark.asyncio +async def test_is_logged_in_accepts_authenticated_only_page_with_content(): + page = MagicMock() + page.url = "https://www.linkedin.com/feed/" + page.locator.return_value.count = AsyncMock(return_value=0) + page.evaluate = AsyncMock(return_value="Home\nMy Network\nJobs") + + result = await is_logged_in(page) + + assert result is True + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_ignores_continue_as_in_page_content(): + page = MagicMock() + page.url = "https://www.linkedin.com/jobs/view/123456/" + page.title = AsyncMock(return_value="Software Engineer at Acme - LinkedIn") + page.evaluate = AsyncMock( + return_value="We need someone to continue as a senior engineer on our team." + ) + + result = await detect_auth_barrier(page) + + assert result is None + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_ignores_choose_account_in_page_content(): + page = MagicMock() + page.url = "https://www.linkedin.com/jobs/view/123456/" + page.title = AsyncMock(return_value="Software Engineer at Acme - LinkedIn") + page.evaluate = AsyncMock( + return_value="You will choose an account strategy for the next quarter." + ) + + result = await detect_auth_barrier(page) + + assert result is None + + +@pytest.mark.asyncio +async def test_detect_auth_barrier_ignores_auth_substrings_in_slugs(): + page = MagicMock() + page.url = "https://www.linkedin.com/company/challenge-labs/" + page.title = AsyncMock(return_value="Challenge Labs | LinkedIn") + page.evaluate = AsyncMock(return_value="Challenge Labs builds developer tools.") + + result = await detect_auth_barrier(page) + + assert result is None + + +@pytest.mark.asyncio +async def test_resolve_remember_me_prompt_clicks_saved_account(): + page = MagicMock() + target = MagicMock() + target.wait_for = AsyncMock() + target.scroll_into_view_if_needed = AsyncMock() + target.click = AsyncMock() + target.first = target + page.locator.return_value = target + page.wait_for_selector = AsyncMock() + page.wait_for_load_state = AsyncMock() + + result = await resolve_remember_me_prompt(page) + + assert result is True + target.click.assert_awaited_once() + page.wait_for_load_state.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_resolve_remember_me_prompt_returns_false_when_absent(): + page = MagicMock() + page.wait_for_selector = AsyncMock(side_effect=Exception("missing")) + + result = await resolve_remember_me_prompt(page) + + assert result is False + + +@pytest.mark.asyncio +async def test_resolve_remember_me_prompt_returns_false_when_container_has_no_button(): + page = MagicMock() + target = MagicMock() + target.wait_for = AsyncMock() + locator = MagicMock() + locator.count = AsyncMock(return_value=0) + locator.first = target + page.locator.return_value = locator + page.wait_for_selector = AsyncMock() + + result = await resolve_remember_me_prompt(page) + + assert result is False + target.wait_for.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_wait_for_manual_login_clicks_saved_account(monkeypatch): + page = MagicMock() + clicked = {"value": False} + + async def fake_resolve(_page): + if not clicked["value"]: + clicked["value"] = True + return True + return False + + async def fake_is_logged_in(_page): + return clicked["value"] + + monkeypatch.setattr( + "linkedin_mcp_server.core.auth.resolve_remember_me_prompt", fake_resolve + ) + monkeypatch.setattr("linkedin_mcp_server.core.auth.is_logged_in", fake_is_logged_in) + + await wait_for_manual_login(page, timeout=1000) + + assert clicked["value"] is True + + +@pytest.mark.asyncio +async def test_wait_for_manual_login_times_out_when_remember_me_repeats(monkeypatch): + page = MagicMock() + + class _FakeLoop: + def __init__(self): + self._times = iter([0.0, 1.1]) + + def time(self): + return next(self._times) + + monkeypatch.setattr( + "linkedin_mcp_server.core.auth.resolve_remember_me_prompt", + AsyncMock(return_value=True), + ) + monkeypatch.setattr( + "linkedin_mcp_server.core.auth.asyncio.get_running_loop", + lambda: _FakeLoop(), + ) + + with pytest.raises(AuthenticationError, match="Manual login timeout"): + await wait_for_manual_login(page, timeout=1000) diff --git a/tests/test_core_browser.py b/tests/test_core_browser.py new file mode 100644 index 00000000..f634b625 --- /dev/null +++ b/tests/test_core_browser.py @@ -0,0 +1,163 @@ +"""Tests for BrowserManager cookie import/export helpers.""" + +import json +from unittest.mock import AsyncMock, MagicMock + +import pytest + +from linkedin_mcp_server.core.browser import BrowserManager + + +def _make_cookie( + name: str, + value: str = "value", + *, + domain: str = ".linkedin.com", +) -> dict[str, str]: + return { + "name": name, + "value": value, + "domain": domain, + "path": "/", + } + + +def _make_browser_manager(tmp_path) -> tuple[BrowserManager, MagicMock]: + browser = BrowserManager(user_data_dir=tmp_path / "profile") + context = MagicMock() + context.clear_cookies = AsyncMock() + context.add_cookies = AsyncMock() + context.storage_state = AsyncMock() + browser._context = context + return browser, context + + +@pytest.mark.asyncio +async def test_import_cookies_imports_bridge_subset_only(tmp_path): + browser, context = _make_browser_manager(tmp_path) + cookie_path = tmp_path / "cookies.json" + cookies = [ + _make_cookie("li_at"), + _make_cookie("JSESSIONID"), + _make_cookie("bcookie"), + _make_cookie("bscookie"), + _make_cookie("lidc"), + _make_cookie("session", domain=".example.com"), + _make_cookie("timezone"), + ] + cookie_path.write_text(json.dumps(cookies)) + + imported = await browser.import_cookies(cookie_path) + + assert imported is True + context.clear_cookies.assert_not_awaited() + context.add_cookies.assert_awaited_once_with( + [cookies[0], cookies[1], cookies[2], cookies[3], cookies[4]] + ) + + +@pytest.mark.asyncio +async def test_import_cookies_uses_bridge_core_debug_preset(tmp_path, monkeypatch): + browser, context = _make_browser_manager(tmp_path) + cookie_path = tmp_path / "cookies.json" + cookies = [ + _make_cookie("li_at"), + _make_cookie("JSESSIONID"), + _make_cookie("bcookie"), + _make_cookie("bscookie"), + _make_cookie("lidc"), + _make_cookie("liap"), + _make_cookie("timezone"), + ] + cookie_path.write_text(json.dumps(cookies)) + monkeypatch.setenv("LINKEDIN_DEBUG_BRIDGE_COOKIE_SET", "bridge_core") + + imported = await browser.import_cookies(cookie_path) + + assert imported is True + context.add_cookies.assert_awaited_once_with(cookies) + + +@pytest.mark.asyncio +async def test_import_cookies_requires_li_at(tmp_path): + browser, context = _make_browser_manager(tmp_path) + cookie_path = tmp_path / "cookies.json" + cookie_path.write_text( + json.dumps( + [ + _make_cookie("JSESSIONID"), + _make_cookie("bcookie"), + ] + ) + ) + + imported = await browser.import_cookies(cookie_path) + + assert imported is False + context.clear_cookies.assert_not_awaited() + context.add_cookies.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_import_cookies_preserves_existing_cookies(tmp_path): + browser, context = _make_browser_manager(tmp_path) + cookie_path = tmp_path / "cookies.json" + cookie_path.write_text( + json.dumps( + [ + _make_cookie("li_at"), + _make_cookie("li_rm"), + _make_cookie("JSESSIONID"), + ] + ) + ) + + imported = await browser.import_cookies(cookie_path) + + assert imported is True + context.clear_cookies.assert_not_awaited() + context.add_cookies.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_export_storage_state_calls_context_storage_state(tmp_path): + browser, context = _make_browser_manager(tmp_path) + storage_state_path = tmp_path / "storage-state.json" + + exported = await browser.export_storage_state(storage_state_path, indexed_db=True) + + assert exported is True + context.storage_state.assert_awaited_once_with( + path=storage_state_path, + indexed_db=True, + ) + + +@pytest.mark.asyncio +async def test_export_storage_state_requires_context(tmp_path): + browser = BrowserManager(user_data_dir=tmp_path / "profile") + + exported = await browser.export_storage_state(tmp_path / "storage-state.json") + + assert exported is False + + +@pytest.mark.asyncio +async def test_close_is_idempotent_and_resets_state(tmp_path): + browser = BrowserManager(user_data_dir=tmp_path / "profile") + browser._page = MagicMock() + context = MagicMock() + context.close = AsyncMock(side_effect=RuntimeError("boom")) + playwright = MagicMock() + playwright.stop = AsyncMock() + browser._context = context + browser._playwright = playwright + + await browser.close() + await browser.close() + + context.close.assert_awaited_once() + playwright.stop.assert_awaited_once() + assert browser._context is None + assert browser._page is None + assert browser._playwright is None diff --git a/tests/test_core_utils.py b/tests/test_core_utils.py new file mode 100644 index 00000000..be87f8ee --- /dev/null +++ b/tests/test_core_utils.py @@ -0,0 +1,147 @@ +"""Tests for core utility functions (rate-limit detection, scrolling, modals).""" + +from unittest.mock import AsyncMock, MagicMock + +import pytest + +from linkedin_mcp_server.core.exceptions import RateLimitError +from linkedin_mcp_server.core.utils import detect_rate_limit + + +@pytest.fixture +def mock_page(): + """Create a mock Patchright page for rate-limit tests.""" + page = MagicMock() + page.url = "https://www.linkedin.com/in/testuser/details/experience/" + + mock_locator = MagicMock() + mock_locator.count = AsyncMock(return_value=0) + mock_locator.inner_text = AsyncMock(return_value="") + page.locator = MagicMock(return_value=mock_locator) + return page + + +class TestDetectRateLimit: + async def test_checkpoint_url_raises(self, mock_page): + mock_page.url = "https://www.linkedin.com/checkpoint/challenge/123" + with pytest.raises(RateLimitError, match="security checkpoint"): + await detect_rate_limit(mock_page) + + async def test_authwall_url_raises(self, mock_page): + mock_page.url = "https://www.linkedin.com/authwall?trk=login" + with pytest.raises(RateLimitError, match="security checkpoint"): + await detect_rate_limit(mock_page) + + async def test_captcha_iframe_raises(self, mock_page): + captcha_locator = MagicMock() + captcha_locator.count = AsyncMock(return_value=1) + + main_locator = MagicMock() + main_locator.count = AsyncMock(return_value=0) + + def locator_side_effect(selector): + if "captcha" in selector: + return captcha_locator + return main_locator + + mock_page.locator = MagicMock(side_effect=locator_side_effect) + with pytest.raises(RateLimitError, match="CAPTCHA"): + await detect_rate_limit(mock_page) + + async def test_normal_page_with_main_skips_body_heuristic(self, mock_page): + """A normal page with
should NOT trigger body text checks.""" + main_locator = MagicMock() + main_locator.count = AsyncMock(return_value=1) + + captcha_locator = MagicMock() + captcha_locator.count = AsyncMock(return_value=0) + + body_locator = MagicMock() + # Body contains a phrase that would false-positive + body_locator.inner_text = AsyncMock( + return_value="Helping SaaS teams slow down churn with data-driven retention" + ) + + def locator_side_effect(selector): + if "captcha" in selector: + return captcha_locator + if selector == "main": + return main_locator + if selector == "body": + return body_locator + return MagicMock(count=AsyncMock(return_value=0)) + + mock_page.locator = MagicMock(side_effect=locator_side_effect) + # Should NOT raise — the page has
, so body heuristic is skipped + await detect_rate_limit(mock_page) + + async def test_error_page_without_main_triggers_heuristic(self, mock_page): + """A short error page without
with rate-limit text should raise.""" + main_locator = MagicMock() + main_locator.count = AsyncMock(return_value=0) + + captcha_locator = MagicMock() + captcha_locator.count = AsyncMock(return_value=0) + + body_locator = MagicMock() + body_locator.inner_text = AsyncMock( + return_value="Too many requests. Slow down." + ) + + def locator_side_effect(selector): + if "captcha" in selector: + return captcha_locator + if selector == "main": + return main_locator + if selector == "body": + return body_locator + return MagicMock(count=AsyncMock(return_value=0)) + + mock_page.locator = MagicMock(side_effect=locator_side_effect) + with pytest.raises(RateLimitError, match="Rate limit message"): + await detect_rate_limit(mock_page) + + async def test_long_body_without_main_does_not_trigger(self, mock_page): + """A page without
but with long body text (>2000 chars) is not an error page.""" + main_locator = MagicMock() + main_locator.count = AsyncMock(return_value=0) + + captcha_locator = MagicMock() + captcha_locator.count = AsyncMock(return_value=0) + + body_locator = MagicMock() + # Long body with a matching phrase buried in content + body_locator.inner_text = AsyncMock( + return_value="x" * 2000 + " try again later" + ) + + def locator_side_effect(selector): + if "captcha" in selector: + return captcha_locator + if selector == "main": + return main_locator + if selector == "body": + return body_locator + return MagicMock(count=AsyncMock(return_value=0)) + + mock_page.locator = MagicMock(side_effect=locator_side_effect) + # Should NOT raise — body is too long to be an error page + await detect_rate_limit(mock_page) + + async def test_normal_url_no_captcha_no_error_passes(self, mock_page): + """A clean normal page passes all checks without raising.""" + main_locator = MagicMock() + main_locator.count = AsyncMock(return_value=1) + + captcha_locator = MagicMock() + captcha_locator.count = AsyncMock(return_value=0) + + def locator_side_effect(selector): + if "captcha" in selector: + return captcha_locator + if selector == "main": + return main_locator + return MagicMock(count=AsyncMock(return_value=0)) + + mock_page.locator = MagicMock(side_effect=locator_side_effect) + await detect_rate_limit(mock_page) diff --git a/tests/test_debug_trace.py b/tests/test_debug_trace.py new file mode 100644 index 00000000..42b0e656 --- /dev/null +++ b/tests/test_debug_trace.py @@ -0,0 +1,114 @@ +import json +from pathlib import Path +from unittest.mock import AsyncMock, MagicMock + +import pytest + +from linkedin_mcp_server.debug_trace import ( + _safe_source_profile_dir, + cleanup_trace_dir, + get_trace_dir, + mark_trace_for_retention, + record_page_trace, + reset_trace_state_for_testing, +) + + +def setup_function(): + reset_trace_state_for_testing() + + +def teardown_function(): + reset_trace_state_for_testing() + + +def test_get_trace_dir_creates_ephemeral_dir_by_default(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + + trace_dir = get_trace_dir() + + assert trace_dir is not None + assert trace_dir.exists() + assert "trace-runs" in str(trace_dir) + + +def test_cleanup_trace_dir_removes_ephemeral_dir_by_default(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + trace_dir = get_trace_dir() + assert trace_dir is not None + + cleanup_trace_dir() + + assert not trace_dir.exists() + + +def test_mark_trace_for_retention_keeps_trace_dir(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + trace_dir = mark_trace_for_retention() + assert trace_dir is not None + + cleanup_trace_dir() + + assert trace_dir.exists() + + +def test_explicit_trace_dir_is_preserved(monkeypatch, tmp_path): + trace_dir = tmp_path / "explicit-trace" + monkeypatch.setenv("LINKEDIN_DEBUG_TRACE_DIR", str(trace_dir)) + + resolved = get_trace_dir() + assert resolved == trace_dir + trace_dir.mkdir(parents=True, exist_ok=True) + + cleanup_trace_dir() + + assert trace_dir.exists() + + +def test_trace_mode_off_disables_trace_dir(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setenv("LINKEDIN_TRACE_MODE", "off") + + assert get_trace_dir() is None + + +@pytest.mark.asyncio +async def test_reset_trace_state_resets_step_counter(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + + page = MagicMock() + page.url = "https://www.linkedin.com/feed/" + page.title = AsyncMock(return_value="LinkedIn") + page.evaluate = AsyncMock(return_value="Feed") + locator = MagicMock() + locator.count = AsyncMock(return_value=0) + page.locator = MagicMock(return_value=locator) + page.context.cookies = AsyncMock(return_value=[]) + page.screenshot = AsyncMock() + + await record_page_trace(page, "first") + trace_dir = get_trace_dir() + assert trace_dir is not None + first_payload = json.loads((trace_dir / "trace.jsonl").read_text().splitlines()[0]) + assert first_payload["step_id"] == 1 + + reset_trace_state_for_testing() + monkeypatch.setenv("USER_DATA_DIR", str((tmp_path / "second") / "profile")) + + await record_page_trace(page, "first-again") + second_trace_dir = get_trace_dir() + assert second_trace_dir is not None + second_payload = json.loads( + (second_trace_dir / "trace.jsonl").read_text().splitlines()[0] + ) + assert second_payload["step_id"] == 1 + + +def test_safe_source_profile_dir_ignores_generic_env_fallback(monkeypatch): + monkeypatch.setenv("USER_DATA_DIR", "/tmp/unrelated-user-data") + monkeypatch.setattr( + "linkedin_mcp_server.debug_trace.get_source_profile_dir", + lambda: (_ for _ in ()).throw(RuntimeError("boom")), + ) + + assert _safe_source_profile_dir() == Path("~/.linkedin-mcp/profile").expanduser() diff --git a/tests/test_error_diagnostics.py b/tests/test_error_diagnostics.py new file mode 100644 index 00000000..7213e1b3 --- /dev/null +++ b/tests/test_error_diagnostics.py @@ -0,0 +1,188 @@ +from pathlib import Path + +import pytest + +from linkedin_mcp_server.error_diagnostics import ( + build_issue_diagnostics, + format_tool_error_with_diagnostics, +) + + +def test_build_issue_diagnostics_includes_existing_issues(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setattr( + "linkedin_mcp_server.error_diagnostics._find_existing_issues", + lambda payload: [ + { + "number": 220, + "title": "[BUG] recent-activity redirect loop in posts on linux-arm64-container", + "url": "https://github.com/stickerdaniel/linkedin-mcp-server/issues/220", + } + ], + ) + + diagnostics = build_issue_diagnostics( + RuntimeError("boom"), + context="extract-page", + target_url="https://www.linkedin.com/in/williamhgates/recent-activity/all/", + section_name="posts", + ) + + assert diagnostics["existing_issues"][0]["number"] == 220 + assert diagnostics["issue_search_skipped"] is False + assert diagnostics["section_name"] == "posts" + assert diagnostics["runtime"]["trace_dir"] is not None + assert "issue_template" not in diagnostics + assert "hostname" not in diagnostics["runtime"] + issue_body = Path(diagnostics["issue_template_path"]).read_text() + assert "## Existing Open Issues" in issue_body + assert "#220" in issue_body + assert "post the gist as a comment there" in issue_body + + +def test_format_tool_error_with_diagnostics_prefers_existing_issue_comment_flow(): + diagnostics = { + "issue_template_path": "/tmp/issue.md", + "existing_issues": [ + { + "number": 220, + "title": "[BUG] recent-activity redirect loop in posts on linux-arm64-container", + "url": "https://github.com/stickerdaniel/linkedin-mcp-server/issues/220", + } + ], + "runtime": { + "trace_dir": "/tmp/trace", + "log_path": "/tmp/trace/server.log", + "suggested_gist_command": 'gh gist create "/tmp/issue.md"', + "current_runtime_id": "linux-arm64-container", + "hostname": "test-host", + }, + } + + message = format_tool_error_with_diagnostics("Scrape failed", diagnostics) + + assert "Matching open issues were found" in message + assert "#220" in message + assert "post it as a comment" in message + assert "File the issue here" not in message + assert "- Runtime: linux-arm64-container" in message + assert "test-host" not in message + + +def test_find_existing_issues_query_failure_is_tolerated(monkeypatch, tmp_path): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + + monkeypatch.setattr( + "linkedin_mcp_server.error_diagnostics.urlopen", + lambda *args, **kwargs: (_ for _ in ()).throw(OSError("no network")), + ) + + diagnostics = build_issue_diagnostics( + RuntimeError("boom"), + context="extract-page", + target_url="https://www.linkedin.com/in/test/", + section_name="main_profile", + ) + + assert diagnostics["existing_issues"] == [] + assert diagnostics["issue_search_skipped"] is False + + +def test_build_issue_diagnostics_omits_missing_server_log_from_gist( + monkeypatch, tmp_path +): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setattr( + "linkedin_mcp_server.error_diagnostics._find_existing_issues", + lambda payload: [], + ) + + diagnostics = build_issue_diagnostics( + RuntimeError("boom"), + context="extract-page", + target_url="https://www.linkedin.com/in/test/", + section_name="main_profile", + ) + + gist_command = diagnostics["runtime"]["suggested_gist_command"] + assert "server.log" not in gist_command + + +@pytest.mark.asyncio +async def test_build_issue_diagnostics_skips_network_search_in_event_loop( + monkeypatch, tmp_path +): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + + called = {"value": False} + + def fail(*args, **kwargs): + called["value"] = True + raise AssertionError("urlopen should not be called inside the event loop") + + monkeypatch.setattr("linkedin_mcp_server.error_diagnostics.urlopen", fail) + + diagnostics = build_issue_diagnostics( + RuntimeError("boom"), + context="extract-page", + target_url="https://www.linkedin.com/in/test/", + section_name="main_profile", + ) + + assert diagnostics["existing_issues"] == [] + assert diagnostics["issue_search_skipped"] is True + assert called["value"] is False + issue_body = Path(diagnostics["issue_template_path"]).read_text() + assert "search was skipped in async server context" in issue_body + + +def test_build_issue_diagnostics_marks_inferred_tool_and_container_runtime( + monkeypatch, tmp_path +): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setattr( + "linkedin_mcp_server.error_diagnostics.get_runtime_id", + lambda: "linux-amd64-container", + ) + monkeypatch.setattr( + "linkedin_mcp_server.error_diagnostics._find_existing_issues", + lambda payload: [], + ) + + diagnostics = build_issue_diagnostics( + RuntimeError("boom"), + context="search_jobs", + target_url="https://www.linkedin.com/jobs/search/?keywords=python", + section_name="search_results", + ) + + issue_body = Path(diagnostics["issue_template_path"]).read_text() + assert "`~/.linkedin-mcp` mounted into `/home/pwuser/.linkedin-mcp`" in issue_body + assert "- [x] Docker" in issue_body + assert " - [x] search_jobs" in issue_body + + +def test_build_issue_diagnostics_keeps_sensitive_runtime_details_out_of_mcp_payload( + monkeypatch, tmp_path +): + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setattr( + "linkedin_mcp_server.error_diagnostics._find_existing_issues", + lambda payload: [], + ) + + diagnostics = build_issue_diagnostics( + RuntimeError("boom"), + context="extract-page", + target_url="https://www.linkedin.com/in/test/", + section_name="main_profile", + ) + + assert diagnostics["issue_template_path"] + assert "issue_template" not in diagnostics + assert "hostname" not in diagnostics["runtime"] + assert "source_profile_dir" not in diagnostics["runtime"] + assert diagnostics["issue_search_skipped"] is False + issue_body = Path(diagnostics["issue_template_path"]).read_text() + assert "## Runtime Diagnostics" in issue_body + assert "Source profile:" in issue_body diff --git a/tests/test_error_handler.py b/tests/test_error_handler.py new file mode 100644 index 00000000..5ce5e560 --- /dev/null +++ b/tests/test_error_handler.py @@ -0,0 +1,110 @@ +import pytest +from fastmcp.exceptions import ToolError + +from linkedin_mcp_server.core.exceptions import ( + NetworkError, + ProfileNotFoundError, + RateLimitError, + ScrapingError, +) +from linkedin_mcp_server.error_handler import raise_tool_error +from linkedin_mcp_server.exceptions import ( + CredentialsNotFoundError, + LinkedInMCPError, + SessionExpiredError, +) + + +def test_raises_tool_error_for_session_expired(): + with pytest.raises(ToolError, match="Session expired"): + raise_tool_error(SessionExpiredError()) + + +def test_raises_tool_error_for_credentials_not_found(): + with pytest.raises(ToolError, match="Authentication not found"): + raise_tool_error(CredentialsNotFoundError("no creds")) + + +def test_raises_tool_error_for_rate_limit_with_custom_wait(): + error = RateLimitError("Rate limited") + error.suggested_wait_time = 600 + with pytest.raises(ToolError, match="Wait 600 seconds"): + raise_tool_error(error) + + +def test_raises_tool_error_for_rate_limit_default_wait(): + error = RateLimitError("Rate limited") + with pytest.raises(ToolError, match="Wait 300 seconds"): + raise_tool_error(error) + + +def test_raises_tool_error_for_profile_not_found(): + with pytest.raises(ToolError, match="Profile not found"): + raise_tool_error(ProfileNotFoundError("gone")) + + +def test_rate_limit_skips_issue_diagnostics(monkeypatch): + monkeypatch.setattr( + "linkedin_mcp_server.error_handler.build_issue_diagnostics", + lambda *args, **kwargs: (_ for _ in ()).throw( + AssertionError("diagnostics should not run") + ), + ) + error = RateLimitError("Rate limited") + + with pytest.raises(ToolError, match="Wait 300 seconds"): + raise_tool_error(error) + + +def test_profile_not_found_skips_issue_diagnostics(monkeypatch): + monkeypatch.setattr( + "linkedin_mcp_server.error_handler.build_issue_diagnostics", + lambda *args, **kwargs: (_ for _ in ()).throw( + AssertionError("diagnostics should not run") + ), + ) + + with pytest.raises(ToolError, match="Profile not found"): + raise_tool_error(ProfileNotFoundError("gone")) + + +def test_raises_tool_error_for_network_error(): + with pytest.raises(ToolError, match="Network error"): + raise_tool_error(NetworkError("timeout")) + + +def test_raises_tool_error_for_scraping_error(): + with pytest.raises(ToolError, match="Scraping failed"): + raise_tool_error(ScrapingError("bad html")) + + +def test_raises_tool_error_for_base_scraper_exception(): + from linkedin_mcp_server.core.exceptions import LinkedInScraperException + + with pytest.raises(ToolError, match="generic scraper error"): + raise_tool_error(LinkedInScraperException("generic scraper error")) + + +def test_raises_tool_error_for_linkedin_mcp_error(): + with pytest.raises(ToolError, match="custom mcp error"): + raise_tool_error(LinkedInMCPError("custom mcp error")) + + +def test_raises_tool_error_for_authentication_error(): + from linkedin_mcp_server.core.exceptions import AuthenticationError + + with pytest.raises(ToolError, match="Authentication failed"): + raise_tool_error(AuthenticationError("bad creds")) + + +def test_raises_tool_error_for_element_not_found(): + from linkedin_mcp_server.core.exceptions import ElementNotFoundError + + with pytest.raises(ToolError, match="Element not found"): + raise_tool_error(ElementNotFoundError("missing")) + + +def test_reraises_unknown_exception(): + """Unknown exceptions are re-raised as-is, not wrapped in ToolError.""" + with pytest.raises(ValueError, match="oops"): + raise_tool_error(ValueError("oops")) diff --git a/tests/test_exceptions.py b/tests/test_exceptions.py new file mode 100644 index 00000000..bcee0a9c --- /dev/null +++ b/tests/test_exceptions.py @@ -0,0 +1,25 @@ +from linkedin_mcp_server.exceptions import ( + CredentialsNotFoundError, + LinkedInMCPError, + SessionExpiredError, +) + + +def test_base_exception(): + err = LinkedInMCPError("test") + assert str(err) == "test" + + +def test_session_expired_default_message(): + err = SessionExpiredError() + assert "expired" in str(err).lower() + + +def test_session_expired_custom_message(): + err = SessionExpiredError("custom") + assert str(err) == "custom" + + +def test_inheritance(): + assert issubclass(SessionExpiredError, LinkedInMCPError) + assert issubclass(CredentialsNotFoundError, LinkedInMCPError) diff --git a/tests/test_fields.py b/tests/test_fields.py new file mode 100644 index 00000000..9a128c01 --- /dev/null +++ b/tests/test_fields.py @@ -0,0 +1,147 @@ +"""Tests for scraping section config dicts and section parsers.""" + +from linkedin_mcp_server.scraping.fields import ( + COMPANY_SECTIONS, + PERSON_SECTIONS, + parse_company_sections, + parse_person_sections, +) + + +class TestPersonSections: + def test_expected_keys(self): + expected = { + "main_profile", + "experience", + "education", + "interests", + "honors", + "languages", + "contact_info", + "posts", + } + assert set(PERSON_SECTIONS) == expected + + def test_contact_info_is_overlay(self): + _suffix, is_overlay = PERSON_SECTIONS["contact_info"] + assert is_overlay is True + + def test_non_overlay_sections(self): + for name, (_suffix, is_overlay) in PERSON_SECTIONS.items(): + if name != "contact_info": + assert is_overlay is False, f"{name} should not be an overlay" + + def test_all_suffixes_start_with_slash(self): + for name, (suffix, _) in PERSON_SECTIONS.items(): + assert suffix.startswith("/"), f"{name} suffix should start with /" + + +class TestCompanySections: + def test_expected_keys(self): + assert set(COMPANY_SECTIONS) == {"about", "posts", "jobs"} + + def test_no_overlays(self): + for name, (_suffix, is_overlay) in COMPANY_SECTIONS.items(): + assert is_overlay is False, f"{name} should not be an overlay" + + +class TestParsePersonSections: + def test_none_returns_baseline_only(self): + requested, unknown = parse_person_sections(None) + assert requested == {"main_profile"} + assert unknown == [] + + def test_empty_string_returns_baseline_only(self): + requested, unknown = parse_person_sections("") + assert requested == {"main_profile"} + assert unknown == [] + + def test_single_section(self): + requested, unknown = parse_person_sections("contact_info") + assert requested == {"main_profile", "contact_info"} + assert unknown == [] + + def test_multiple_sections(self): + requested, unknown = parse_person_sections("experience,education") + assert requested == {"main_profile", "experience", "education"} + assert unknown == [] + + def test_invalid_names_returned(self): + requested, unknown = parse_person_sections("experience,bogus,education") + assert requested == {"main_profile", "experience", "education"} + assert unknown == ["bogus"] + + def test_multiple_invalid_names(self): + requested, unknown = parse_person_sections("experience,foo,bar") + assert requested == {"main_profile", "experience"} + assert unknown == ["foo", "bar"] + + def test_whitespace_and_case_handling(self): + requested, unknown = parse_person_sections(" Experience , EDUCATION ") + assert requested == {"main_profile", "experience", "education"} + assert unknown == [] + + def test_baseline_passed_explicitly_not_unknown(self): + requested, unknown = parse_person_sections("main_profile,experience") + assert requested == {"main_profile", "experience"} + assert unknown == [] + + def test_all_sections(self): + requested, unknown = parse_person_sections( + "experience,education,interests,honors,languages,contact_info,posts" + ) + assert requested == set(PERSON_SECTIONS) + assert unknown == [] + + +class TestParseCompanySections: + def test_none_returns_baseline_only(self): + requested, unknown = parse_company_sections(None) + assert requested == {"about"} + assert unknown == [] + + def test_empty_string_returns_baseline_only(self): + requested, unknown = parse_company_sections("") + assert requested == {"about"} + assert unknown == [] + + def test_single_section(self): + requested, unknown = parse_company_sections("posts") + assert requested == {"about", "posts"} + assert unknown == [] + + def test_multiple_sections(self): + requested, unknown = parse_company_sections("posts,jobs") + assert requested == {"about", "posts", "jobs"} + assert unknown == [] + + def test_invalid_names_returned(self): + requested, unknown = parse_company_sections("posts,bogus") + assert requested == {"about", "posts"} + assert unknown == ["bogus"] + + def test_baseline_passed_explicitly_not_unknown(self): + requested, unknown = parse_company_sections("about,posts") + assert requested == {"about", "posts"} + assert unknown == [] + + def test_whitespace_and_case_handling(self): + requested, unknown = parse_company_sections(" Posts , JOBS ") + assert requested == {"about", "posts", "jobs"} + assert unknown == [] + + +class TestConfigCompleteness: + """Ensure every config dict section has a valid suffix.""" + + def test_person_sections_all_have_suffixes(self): + for name, (suffix, _) in PERSON_SECTIONS.items(): + assert isinstance(suffix, str) and len(suffix) > 0, ( + f"{name} has empty suffix" + ) + + def test_company_sections_all_have_suffixes(self): + for name, (suffix, _) in COMPANY_SECTIONS.items(): + assert isinstance(suffix, str) and len(suffix) > 0, ( + f"{name} has empty suffix" + ) diff --git a/tests/test_link_metadata.py b/tests/test_link_metadata.py new file mode 100644 index 00000000..84d84e2c --- /dev/null +++ b/tests/test_link_metadata.py @@ -0,0 +1,524 @@ +"""Tests for compact LinkedIn reference extraction helpers.""" + +from urllib.parse import quote + +from linkedin_mcp_server.scraping.link_metadata import ( + RawReference, + build_references, + dedupe_references, + normalize_url, +) + + +class TestBuildReferences: + def test_canonicalizes_and_types_linkedin_urls(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/in/williamhgates?miniProfileUrn=123", + "text": "Bill Gates", + "heading": "Featured", + }, + { + "href": "https://www.linkedin.com/company/gates-foundation/posts/", + "text": "Gates Foundation", + "heading": "Experience", + }, + { + "href": "https://www.linkedin.com/pulse/phone-call-saves-lives-bill-gates-yspvc?trackingId=123", + "text": "A phone call that saves lives", + }, + ], + "main_profile", + ) + + assert references == [ + { + "kind": "person", + "url": "/in/williamhgates/", + "text": "Bill Gates", + "context": "featured", + }, + { + "kind": "company", + "url": "/company/gates-foundation/", + "text": "Gates Foundation", + "context": "experience", + }, + { + "kind": "article", + "url": "/pulse/phone-call-saves-lives-bill-gates-yspvc/", + "text": "A phone call that saves lives", + "context": "top card", + }, + ] + + def test_preserves_person_slug_named_details(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/in/details/", + "text": "Details Person", + } + ], + "main_profile", + ) + + assert references == [ + { + "kind": "person", + "url": "/in/details/", + "text": "Details Person", + "context": "top card", + } + ] + + def test_drops_person_details_subpage(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/in/williamhgates/details/experience/", + "text": "Bill Gates", + } + ], + "main_profile", + ) + + assert references == [] + + def test_unwraps_redirect_and_drops_junk(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/redir/redirect/?url=https%3A%2F%2Fgatesnot.es%2Ftgn&urlhash=abc", + "text": "Gates Notes", + }, + { + "href": "blob:https://www.linkedin.com/123", + "text": "Video", + }, + { + "href": "#caret-small", + "text": "", + }, + { + "href": "https://www.linkedin.com/help/linkedin/", + "text": "Questions?", + }, + ], + "posts", + ) + + assert references == [ + { + "kind": "external", + "url": "https://gatesnot.es/tgn", + "text": "Gates Notes", + "context": "post attachment", + } + ] + + def test_drops_non_http_external_schemes(self): + references = build_references( + [ + { + "href": "data:text/html,

hello

", + "text": "Inline payload", + }, + { + "href": "ftp://example.com/report.csv", + "text": "FTP report", + }, + { + "href": "https://example.com/report.csv", + "text": "HTTPS report", + }, + ], + "posts", + ) + + assert references == [ + { + "kind": "external", + "url": "https://example.com/report.csv", + "text": "HTTPS report", + "context": "post attachment", + } + ] + + def test_dedupes_external_tracking_variants(self): + references = build_references( + [ + { + "href": "https://example.com/report?utm_source=linkedin", + "text": "Report", + }, + { + "href": "https://example.com/report?utm_source=share", + "text": "Detailed annual report", + }, + ], + "posts", + ) + + assert references == [ + { + "kind": "external", + "url": "https://example.com/report", + "text": "Detailed annual report", + "context": "post attachment", + } + ] + + def test_prefers_cleaner_duplicate_label(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/newsletters/gates-notes-123/", + "text": "View my newsletter", + "aria_label": "Gates Notes", + }, + { + "href": "https://www.linkedin.com/newsletters/gates-notes-123/", + "text": "Gates Notes Gates Notes", + }, + ], + "posts", + ) + + assert references == [ + { + "kind": "newsletter", + "url": "/newsletters/gates-notes-123/", + "text": "Gates Notes", + "context": "post attachment", + } + ] + + def test_normalize_url_unwraps_nested_redirects_within_cap(self): + target = "https://example.com/report" + nested = "https://www.linkedin.com/redir/redirect/?url=" + quote( + "https://www.linkedin.com/redir/redirect/?url=" + quote(target, safe=""), + safe="", + ) + + assert normalize_url(nested) == target + + def test_normalize_url_drops_redirect_chain_beyond_cap(self): + target = "https://example.com/report" + href = target + for _ in range(7): + href = "https://www.linkedin.com/redir/redirect/?url=" + quote( + href, safe="" + ) + + assert normalize_url(href) is None + + def test_prefers_shorter_clean_label_over_merged_visible_text(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/pulse/test-post?trackingId=123", + "text": "Gates Notes Gates Notes A phone call that saves lives Bill Gates", + "aria_label": "Open article: A phone call that saves lives by Bill Gates â€ĸ 3 min read", + } + ], + "posts", + ) + + assert references == [ + { + "kind": "article", + "url": "/pulse/test-post/", + "text": "A phone call that saves lives", + "context": "post attachment", + } + ] + + def test_rejects_single_character_labels(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/in/williamhgates/", + "text": "1", + "aria_label": "Bill Gates", + } + ], + "main_profile", + ) + + assert references == [ + { + "kind": "person", + "url": "/in/williamhgates/", + "text": "Bill Gates", + "context": "top card", + } + ] + + def test_preserves_words_starting_with_view(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/company/viewpoint-economics/", + "text": "Viewpoint Economics", + } + ], + "about", + ) + + assert references == [ + { + "kind": "company", + "url": "/company/viewpoint-economics/", + "text": "Viewpoint Economics", + "context": "top card", + } + ] + + def test_prefers_company_post_context_for_feed_posts(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/feed/update/urn:li:activity:123/", + "text": "Original company post", + "in_article": True, + } + ], + "posts", + ) + + assert references == [ + { + "kind": "feed_post", + "url": "/feed/update/urn:li:activity:123/", + "text": "Original company post", + "context": "company post", + } + ] + + def test_drops_social_proof_company_labels(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/company/gates-foundation/", + "text": "Falguni & 8 other connections follow this page", + }, + { + "href": "https://www.linkedin.com/company/gates-foundation/", + "text": "Gates Foundation", + }, + ], + "about", + ) + + assert references == [ + { + "kind": "company", + "url": "/company/gates-foundation/", + "text": "Gates Foundation", + "context": "top card", + } + ] + + def test_drops_nav_and_footer_anchors(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/in/williamhgates/", + "text": "Bill Gates", + "in_nav": True, + }, + { + "href": "https://www.linkedin.com/company/gates-foundation/", + "text": "Gates Foundation", + "in_footer": True, + }, + ], + "main_profile", + ) + + assert references == [] + + def test_caps_results_per_section(self): + raw: list[RawReference] = [ + { + "href": f"https://www.linkedin.com/company/test-{idx}/", + "text": f"Company {idx}", + } + for idx in range(20) + ] + + references = build_references(raw, "about") + + assert len(references) == 12 + assert references[0]["url"] == "/company/test-0/" + assert references[-1]["url"] == "/company/test-11/" + + def test_caps_jobs_section_more_tightly(self): + raw: list[RawReference] = [ + { + "href": f"https://www.linkedin.com/jobs/view/{idx}/", + "text": f"Job {idx}", + } + for idx in range(20) + ] + + references = build_references(raw, "jobs") + + assert len(references) == 8 + assert references[0]["url"] == "/jobs/view/0/" + assert references[-1]["url"] == "/jobs/view/7/" + + def test_uses_default_cap_for_unknown_section(self): + raw: list[RawReference] = [ + { + "href": f"https://www.linkedin.com/company/test-{idx}/", + "text": f"Company {idx}", + } + for idx in range(20) + ] + + references = build_references(raw, "unknown_section") + + assert len(references) == 12 + + def test_prefers_richer_duplicate_text(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/jobs/view/12345/", + "text": "Job", + }, + { + "href": "https://www.linkedin.com/jobs/view/12345/", + "text": "Senior Software Engineer", + }, + ], + "search_results", + ) + + assert references == [ + { + "kind": "job", + "url": "/jobs/view/12345/", + "text": "Senior Software Engineer", + "context": "job result", + } + ] + + def test_uses_search_result_contexts(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/jobs/view/12345/", + "text": "Senior Engineer", + }, + { + "href": "https://www.linkedin.com/in/stickerdaniel/", + "text": "Daniel Sticker", + }, + ], + "search_results", + ) + + assert references == [ + { + "kind": "job", + "url": "/jobs/view/12345/", + "text": "Senior Engineer", + "context": "job result", + }, + { + "kind": "person", + "url": "/in/stickerdaniel/", + "text": "Daniel Sticker", + "context": "search result", + }, + ] + + def test_uses_job_posting_context_for_job_pages(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/company/acme/", + "text": "Acme", + } + ], + "job_posting", + ) + + assert references == [ + { + "kind": "company", + "url": "/company/acme/", + "text": "Acme", + "context": "job posting", + } + ] + + def test_does_not_treat_lookalike_domains_as_linkedin(self): + references = build_references( + [ + { + "href": "https://www.notlinkedin.com/company/fake/about/", + "text": "Fake Company", + } + ], + "about", + ) + + assert references == [ + { + "kind": "external", + "url": "https://www.notlinkedin.com/company/fake/about/", + "text": "Fake Company", + "context": "top card", + } + ] + + def test_keeps_company_about_routes(self): + references = build_references( + [ + { + "href": "https://www.linkedin.com/company/legalzoom/about/", + "text": "LegalZoom", + } + ], + "about", + ) + + assert references == [ + { + "kind": "company", + "url": "/company/legalzoom/", + "text": "LegalZoom", + "context": "top card", + } + ] + + def test_cross_page_dedupe_keeps_better_reference(self): + references = dedupe_references( + [ + { + "kind": "job", + "url": "/jobs/view/123/", + "text": "Job", + }, + { + "kind": "job", + "url": "/jobs/view/123/", + "text": "Senior Software Engineer", + "context": "job result", + }, + ] + ) + + assert references == [ + { + "kind": "job", + "url": "/jobs/view/123/", + "text": "Senior Software Engineer", + "context": "job result", + } + ] diff --git a/tests/test_logging_config.py b/tests/test_logging_config.py new file mode 100644 index 00000000..7fe8bee7 --- /dev/null +++ b/tests/test_logging_config.py @@ -0,0 +1,62 @@ +import logging + +from linkedin_mcp_server.debug_trace import get_trace_dir, reset_trace_state_for_testing +from linkedin_mcp_server.logging_config import configure_logging, teardown_trace_logging + + +def setup_function(): + reset_trace_state_for_testing() + + +def teardown_function(): + teardown_trace_logging() + reset_trace_state_for_testing() + + +def test_configure_logging_registers_trace_cleanup_once(monkeypatch, tmp_path): + registrations = [] + + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setattr( + "linkedin_mcp_server.logging_config.atexit.register", + lambda fn: registrations.append(fn), + ) + monkeypatch.setattr( + "linkedin_mcp_server.logging_config._TRACE_CLEANUP_REGISTERED", + False, + ) + + configure_logging() + configure_logging() + + assert registrations == [teardown_trace_logging] + + +def test_registered_trace_cleanup_removes_ephemeral_trace_dir(monkeypatch, tmp_path): + registrations = [] + + monkeypatch.setenv("USER_DATA_DIR", str(tmp_path / "profile")) + monkeypatch.setattr( + "linkedin_mcp_server.logging_config.atexit.register", + lambda fn: registrations.append(fn), + ) + monkeypatch.setattr( + "linkedin_mcp_server.logging_config._TRACE_CLEANUP_REGISTERED", + False, + ) + + configure_logging() + trace_dir = get_trace_dir() + + assert trace_dir is not None + assert trace_dir.exists() + assert registrations == [teardown_trace_logging] + + registrations[0]() + + assert not trace_dir.exists() + assert not any( + handler + for handler in logging.getLogger().handlers + if isinstance(handler, logging.FileHandler) + ) diff --git a/tests/test_scraping.py b/tests/test_scraping.py new file mode 100644 index 00000000..279086e9 --- /dev/null +++ b/tests/test_scraping.py @@ -0,0 +1,1775 @@ +"""Tests for the LinkedInExtractor scraping engine.""" + +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + +from linkedin_mcp_server.core.exceptions import AuthenticationError +from linkedin_mcp_server.scraping.extractor import ( + ExtractedSection, + LinkedInExtractor, + _RATE_LIMITED_MSG, + _truncate_linkedin_noise, + strip_linkedin_noise, +) +from linkedin_mcp_server.scraping.link_metadata import Reference + + +def extracted( + text: str, + references: list[Reference] | None = None, + error: dict | None = None, +) -> ExtractedSection: + """Create an ExtractedSection for tests.""" + return ExtractedSection(text=text, references=references or [], error=error) + + +class TestBuildJobSearchUrl: + """Tests for _build_job_search_url URL construction.""" + + def test_keywords_only(self): + url = LinkedInExtractor._build_job_search_url("python developer") + assert url == "https://www.linkedin.com/jobs/search/?keywords=python+developer" + + def test_with_location(self): + url = LinkedInExtractor._build_job_search_url("python", location="Remote") + assert "keywords=python" in url + assert "location=Remote" in url + + def test_date_posted_normalization(self): + url = LinkedInExtractor._build_job_search_url("python", date_posted="past_week") + assert "f_TPR=r604800" in url + + def test_date_posted_passthrough(self): + url = LinkedInExtractor._build_job_search_url("python", date_posted="r3600") + assert "f_TPR=r3600" in url + + def test_experience_level_normalization(self): + url = LinkedInExtractor._build_job_search_url( + "python", experience_level="entry" + ) + assert "f_E=2" in url + + def test_experience_level_csv(self): + url = LinkedInExtractor._build_job_search_url( + "python", experience_level="entry,director" + ) + assert "f_E=2,5" in url + + def test_work_type_normalization(self): + url = LinkedInExtractor._build_job_search_url("python", work_type="remote") + assert "f_WT=2" in url + + def test_work_type_csv(self): + url = LinkedInExtractor._build_job_search_url( + "python", work_type="on_site,hybrid" + ) + assert "f_WT=1,3" in url + + def test_easy_apply(self): + url = LinkedInExtractor._build_job_search_url("python", easy_apply=True) + assert "f_EA=true" in url + + def test_easy_apply_false_omitted(self): + url = LinkedInExtractor._build_job_search_url("python", easy_apply=False) + assert "f_EA" not in url + + def test_sort_by_normalization(self): + url = LinkedInExtractor._build_job_search_url("python", sort_by="date") + assert "sortBy=DD" in url + + def test_job_type_normalization(self): + url = LinkedInExtractor._build_job_search_url("python", job_type="full_time") + assert "f_JT=F" in url + + def test_job_type_csv(self): + url = LinkedInExtractor._build_job_search_url( + "python", job_type="full_time,contract" + ) + assert "f_JT=F,C" in url + + def test_job_type_passthrough(self): + url = LinkedInExtractor._build_job_search_url("python", job_type="F") + assert "f_JT=F" in url + + def test_all_filters_combined(self): + url = LinkedInExtractor._build_job_search_url( + "python", + location="Berlin", + date_posted="past_week", + experience_level="entry,mid_senior", + work_type="remote", + easy_apply=True, + sort_by="date", + ) + assert "keywords=python" in url + assert "location=Berlin" in url + assert "f_TPR=r604800" in url + assert "f_E=2,4" in url + assert "f_WT=2" in url + assert "f_EA=true" in url + assert "sortBy=DD" in url + + +@pytest.fixture +def mock_page(): + """Create a mock Patchright page.""" + page = MagicMock() + page.goto = AsyncMock() + page.title = AsyncMock(return_value="LinkedIn") + page.wait_for_selector = AsyncMock() + page.wait_for_function = AsyncMock() + page.evaluate = AsyncMock( + return_value={"source": "root", "text": "Sample page text", "references": []} + ) + page.url = "https://www.linkedin.com/in/testuser/" + page.locator = MagicMock() + # Default: no modals, no CAPTCHA + mock_locator = MagicMock() + mock_locator.count = AsyncMock(return_value=0) + mock_locator.is_visible = AsyncMock(return_value=False) + mock_locator.first = mock_locator + mock_locator.inner_text = AsyncMock(return_value="normal page content") + page.locator.return_value = mock_locator + page.main_frame = object() + page.on = MagicMock() + page.remove_listener = MagicMock() + return page + + +class TestExtractPage: + async def test_extract_page_returns_text(self, mock_page): + mock_page.evaluate = AsyncMock( + return_value={ + "source": "root", + "text": "Sample profile text", + "references": [], + } + ) + extractor = LinkedInExtractor(mock_page) + # Patch scroll_to_bottom and detect_rate_limit to avoid complex mock chains + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + result = await extractor.extract_page( + "https://www.linkedin.com/in/testuser/", + section_name="main_profile", + ) + + assert result.text == "Sample profile text" + assert result.references == [] + mock_page.goto.assert_awaited_once() + + async def test_root_content_filters_empty_href_before_resolution(self, mock_page): + mock_page.evaluate = AsyncMock( + return_value={ + "source": "root", + "text": "Sample profile text", + "references": [], + } + ) + extractor = LinkedInExtractor(mock_page) + + await extractor._extract_root_content(["main"]) + + await_args = mock_page.evaluate.await_args + assert await_args is not None + script = await_args.args[0] + assert "MAX_HEADING_CONTAINERS = 300" in script + assert "MAX_REFERENCE_ANCHORS = 500" in script + assert "const getPreviousHeading = node =>" in script + assert "index < 3" in script + assert "if (!rawHref || rawHref === '#')" in script + assert ".slice(0, MAX_REFERENCE_ANCHORS)" in script + assert "in_list" not in script + assert ".filter(Boolean);" in script + + async def test_extract_page_returns_empty_on_failure(self, mock_page): + mock_page.goto = AsyncMock(side_effect=Exception("Network error")) + extractor = LinkedInExtractor(mock_page) + + with patch( + "linkedin_mcp_server.scraping.extractor.build_issue_diagnostics", + return_value={"issue_template_path": "/tmp/issue.md"}, + ): + result = await extractor.extract_page( + "https://www.linkedin.com/in/bad/", + section_name="main_profile", + ) + assert result.text == "" + assert result.references == [] + assert result.error == {"issue_template_path": "/tmp/issue.md"} + + async def test_extract_page_raises_auth_error_for_account_picker(self, mock_page): + mock_page.goto = AsyncMock(side_effect=Exception("net::ERR_TOO_MANY_REDIRECTS")) + extractor = LinkedInExtractor(mock_page) + + with ( + patch( + "linkedin_mcp_server.scraping.extractor.detect_auth_barrier", + new_callable=AsyncMock, + return_value="auth barrier text: welcome back + sign in using another account", + ), + pytest.raises(AuthenticationError, match="--login"), + ): + await extractor.extract_page( + "https://www.linkedin.com/in/testuser/", + section_name="main_profile", + ) + + async def test_rate_limit_detected(self, mock_page): + from linkedin_mcp_server.core.exceptions import RateLimitError + + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + side_effect=RateLimitError("Rate limited", suggested_wait_time=3600), + ), + pytest.raises(RateLimitError), + ): + await extractor.extract_page( + "https://www.linkedin.com/in/testuser/", + section_name="main_profile", + ) + + async def test_returns_rate_limited_msg_after_retry(self, mock_page): + """When both attempts return only noise, surface rate limit message.""" + noise_only = ( + "More profiles for you\n\n" + "You've approached your profile search limit\n\n" + "About\nAccessibility\nTalent Solutions" + ) + mock_page.evaluate = AsyncMock( + return_value={"source": "root", "text": noise_only, "references": []} + ) + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.extract_page( + "https://www.linkedin.com/in/testuser/details/experience/", + section_name="experience", + ) + + assert result.text == _RATE_LIMITED_MSG + # goto called twice (initial + retry) + assert mock_page.goto.await_count == 2 + + async def test_retry_succeeds_after_rate_limit(self, mock_page): + """When first attempt is rate-limited but retry succeeds, return content.""" + noise_only = "More profiles for you\n\nAbout\nAccessibility\nTalent Solutions" + call_count = 0 + + async def evaluate_side_effect(*args, **kwargs): + nonlocal call_count + call_count += 1 + if call_count <= 1: + return noise_only + return "Education\nHarvard University\n1973 – 1975" + + async def root_content_side_effect(*args, **kwargs): + return { + "source": "root", + "text": await evaluate_side_effect(), + "references": [], + } + + mock_page.evaluate = AsyncMock(side_effect=root_content_side_effect) + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.extract_page( + "https://www.linkedin.com/in/testuser/details/education/", + section_name="education", + ) + + assert result.text == "Education\nHarvard University\n1973 – 1975" + + async def test_media_only_controls_are_not_misclassified_as_rate_limited( + self, mock_page + ): + mock_page.evaluate = AsyncMock( + return_value={ + "source": "root", + "text": "Play\nLoaded: 100.00%\nRemaining time 0:07\nShow captions", + "references": [], + } + ) + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + result = await extractor._extract_page_once( + "https://www.linkedin.com/in/testuser/recent-activity/all/", + section_name="posts", + ) + + assert result.text == "" + assert result.references == [] + + async def test_extract_search_page_raises_auth_error_for_login_barrier( + self, mock_page + ): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_navigate_to_page", + new_callable=AsyncMock, + side_effect=AuthenticationError("Run with --login"), + ), + pytest.raises(AuthenticationError, match="--login"), + ): + await extractor._extract_search_page_once( + "https://www.linkedin.com/jobs/search/?keywords=test", + section_name="search_results", + ) + + +class TestNavigationDiagnostics: + async def test_goto_with_auth_checks_clicks_remember_me_and_retries( + self, mock_page + ): + extractor = LinkedInExtractor(mock_page) + + async def goto_side_effect(*args, **kwargs): + if mock_page.goto.await_count == 1: + raise Exception("net::ERR_TOO_MANY_REDIRECTS") + return None + + mock_page.goto = AsyncMock(side_effect=goto_side_effect) + + with ( + patch( + "linkedin_mcp_server.scraping.extractor.resolve_remember_me_prompt", + new_callable=AsyncMock, + side_effect=[True], + ) as mock_resolve, + patch( + "linkedin_mcp_server.scraping.extractor.detect_auth_barrier_quick", + new_callable=AsyncMock, + return_value=None, + ), + ): + await extractor._goto_with_auth_checks( + "https://www.linkedin.com/in/testuser/" + ) + + assert mock_page.goto.await_count == 2 + mock_resolve.assert_awaited_once() + + async def test_goto_with_auth_checks_unhooks_outer_listener_before_retry( + self, mock_page + ): + extractor = LinkedInExtractor(mock_page) + listener_events: list[str] = [] + + def record_on(event_name, callback): + listener_events.append(f"on:{event_name}") + + def record_remove(event_name, callback): + listener_events.append(f"off:{event_name}") + + mock_page.on.side_effect = record_on + mock_page.remove_listener.side_effect = record_remove + + with ( + patch( + "linkedin_mcp_server.scraping.extractor.resolve_remember_me_prompt", + new_callable=AsyncMock, + return_value=True, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_auth_barrier_quick", + new_callable=AsyncMock, + side_effect=["account picker", None], + ), + ): + await extractor._goto_with_auth_checks( + "https://www.linkedin.com/in/testuser/" + ) + + assert listener_events == [ + "on:framenavigated", + "off:framenavigated", + "on:framenavigated", + "off:framenavigated", + ] + + async def test_goto_with_auth_checks_records_original_failure_before_retry( + self, mock_page + ): + extractor = LinkedInExtractor(mock_page) + mock_page.goto = AsyncMock( + side_effect=[ + Exception("net::ERR_TOO_MANY_REDIRECTS"), + Exception("retry failed"), + ] + ) + + with ( + patch( + "linkedin_mcp_server.scraping.extractor.resolve_remember_me_prompt", + new_callable=AsyncMock, + side_effect=[True, False], + ), + patch( + "linkedin_mcp_server.scraping.extractor.record_page_trace", + new_callable=AsyncMock, + ) as mock_trace, + patch( + "linkedin_mcp_server.scraping.extractor.detect_auth_barrier", + new_callable=AsyncMock, + return_value=None, + ), + pytest.raises(Exception, match="retry failed"), + ): + await extractor._goto_with_auth_checks( + "https://www.linkedin.com/in/testuser/" + ) + + trace_steps = [call.args[1] for call in mock_trace.await_args_list] + assert "extractor-navigation-error-before-remember-me-retry" in trace_steps + + trace_call = next( + call + for call in mock_trace.await_args_list + if call.args[1] == "extractor-navigation-error-before-remember-me-retry" + ) + assert ( + trace_call.kwargs["extra"]["error"] + == "Exception: net::ERR_TOO_MANY_REDIRECTS" + ) + + async def test_goto_with_auth_checks_logs_failure_context(self, mock_page): + extractor = LinkedInExtractor(mock_page) + mock_page.goto = AsyncMock(side_effect=Exception("net::ERR_TOO_MANY_REDIRECTS")) + + with ( + patch( + "linkedin_mcp_server.scraping.extractor.resolve_remember_me_prompt", + new_callable=AsyncMock, + return_value=False, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_auth_barrier", + new_callable=AsyncMock, + return_value=None, + ), + patch.object( + extractor, + "_log_navigation_failure", + new_callable=AsyncMock, + ) as mock_log_failure, + pytest.raises(Exception, match="ERR_TOO_MANY_REDIRECTS"), + ): + await extractor._goto_with_auth_checks( + "https://www.linkedin.com/in/testuser/" + ) + + mock_log_failure.assert_awaited_once() + mock_page.on.assert_called_once() + mock_page.remove_listener.assert_called_once() + + +class TestScrapePersonUrls: + """Test that scrape_person visits the correct URLs per section set.""" + + async def test_baseline_always_included(self, mock_page): + """Passing only experience still visits main profile.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("testuser", {"experience"}) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert "main_profile" in result["sections"] + assert any(u.endswith("/in/testuser/") for u in urls) + assert any("/details/experience/" in u for u in urls) + + async def test_basic_info_only_visits_main_profile(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("profile text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("testuser", {"main_profile"}) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert len(urls) == 1 + assert urls[0].endswith("/in/testuser/") + assert set(result["sections"]) == {"main_profile"} + + async def test_scrape_person_returns_section_errors(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + side_effect=[ + extracted("profile text"), + extracted("", error={"issue_template_path": "/tmp/issue.md"}), + ], + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("testuser", {"posts"}) + + assert result["sections"]["main_profile"] == "profile text" + assert ( + result["section_errors"]["posts"]["issue_template_path"] == "/tmp/issue.md" + ) + + async def test_experience_education_visits_correct_urls(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person( + "testuser", {"main_profile", "experience", "education"} + ) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert len(urls) == 3 + assert any(u.endswith("/in/testuser/") for u in urls) + assert any("/details/experience/" in u for u in urls) + assert any("/details/education/" in u for u in urls) + assert set(result["sections"]) == {"main_profile", "experience", "education"} + + async def test_all_sections_visit_all_urls(self, mock_page): + extractor = LinkedInExtractor(mock_page) + all_sections = { + "main_profile", + "experience", + "education", + "interests", + "honors", + "languages", + "contact_info", + "posts", + } + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted("contact text"), + ) as mock_overlay, + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("testuser", all_sections) + + page_urls = [call.args[0] for call in mock_extract.call_args_list] + overlay_urls = [call.args[0] for call in mock_overlay.call_args_list] + all_urls = page_urls + overlay_urls + # 7 full-page sections + 1 overlay (contact_info) + assert len(page_urls) == 7 + assert len(overlay_urls) == 1 + # Verify each expected suffix was navigated + assert any(u.endswith("/in/testuser/") for u in all_urls) + assert any("/details/experience/" in u for u in all_urls) + assert any("/details/education/" in u for u in all_urls) + assert any("/details/interests/" in u for u in all_urls) + assert any("/details/honors/" in u for u in all_urls) + assert any("/details/languages/" in u for u in all_urls) + assert any("/overlay/contact-info/" in u for u in overlay_urls) + assert any("/recent-activity/all/" in u for u in all_urls) + assert set(result["sections"]) == all_sections + + async def test_posts_visits_recent_activity(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("Post 1\nPost 2"), + ) as mock_extract, + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("test-user", {"posts"}) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert any("/recent-activity/all/" in url for url in urls) + assert "posts" in result["sections"] + + async def test_references_are_grouped_by_section(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + side_effect=[ + extracted( + "profile text", + [ + { + "kind": "person", + "url": "/in/testuser/", + "text": "Test User", + } + ], + ), + extracted( + "post text", + [ + { + "kind": "article", + "url": "/pulse/test-post/", + "text": "Test post", + } + ], + ), + ], + ), + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("testuser", {"posts"}) + + assert result["references"] == { + "main_profile": [ + {"kind": "person", "url": "/in/testuser/", "text": "Test User"} + ], + "posts": [ + {"kind": "article", "url": "/pulse/test-post/", "text": "Test post"} + ], + } + + async def test_error_isolation(self, mock_page): + """One section failing doesn't block others.""" + + async def extract_with_failure(url, *args, **kwargs): + if "experience" in url: + raise Exception("Simulated failure") + return extracted(f"text for {url}") + + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + side_effect=extract_with_failure, + ), + patch( + "linkedin_mcp_server.scraping.extractor.build_issue_diagnostics", + return_value={"issue_template_path": "/tmp/issue.md"}, + ), + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person( + "testuser", {"main_profile", "experience", "education"} + ) + + # main_profile and education should have sections, experience should not + assert "main_profile" in result["sections"] + assert "education" in result["sections"] + assert "experience" not in result["sections"] + assert result["section_errors"]["experience"]["issue_template_path"] == ( + "/tmp/issue.md" + ) + + async def test_rate_limited_sections_are_omitted(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + side_effect=[ + extracted(_RATE_LIMITED_MSG), + extracted("Post text"), + ], + ), + patch.object( + extractor, + "_extract_overlay", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_person("testuser", {"posts"}) + + assert "main_profile" not in result["sections"] + assert result["sections"]["posts"] == "Post text" + + +class TestScrapeCompany: + async def test_company_baseline_always_included(self, mock_page): + """Passing only posts still visits about page.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_company("testcorp", {"posts"}) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert any("/about/" in u for u in urls) + assert any("/posts/" in u for u in urls) + assert "about" in result["sections"] + assert "posts" in result["sections"] + + async def test_about_only_visits_about(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("about text"), + ) as mock_extract, + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_company("testcorp", {"about"}) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert len(urls) == 1 + assert "/about/" in urls[0] + assert set(result["sections"]) == {"about"} + + async def test_all_sections_visit_correct_urls(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_company( + "testcorp", {"about", "posts", "jobs"} + ) + + urls = [call.args[0] for call in mock_extract.call_args_list] + assert len(urls) == 3 + assert any("/about/" in u for u in urls) + assert any("/posts/" in u for u in urls) + assert any("/jobs/" in u for u in urls) + assert set(result["sections"]) == {"about", "posts", "jobs"} + + async def test_rate_limited_company_sections_are_omitted(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + side_effect=[ + extracted(_RATE_LIMITED_MSG), + extracted("Posts text"), + ], + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.scrape_company("testcorp", {"posts"}) + + assert "about" not in result["sections"] + assert result["sections"]["posts"] == "Posts text" + + +class TestScrapeJob: + async def test_scrape_job(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted("Job: Software Engineer"), + ): + result = await extractor.scrape_job("12345") + + assert result["url"] == "https://www.linkedin.com/jobs/view/12345/" + assert "job_posting" in result["sections"] + assert "pages_visited" not in result + assert "sections_requested" not in result + + async def test_scrape_job_omits_rate_limited_sentinel(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted(_RATE_LIMITED_MSG), + ): + result = await extractor.scrape_job("12345") + + assert result["sections"] == {} + + async def test_scrape_job_omits_orphaned_references_when_text_empty( + self, mock_page + ): + extractor = LinkedInExtractor(mock_page) + with patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted( + "", + [{"kind": "job", "url": "/jobs/view/12345/", "text": "Engineer"}], + ), + ): + result = await extractor.scrape_job("12345") + + assert result["sections"] == {} + assert "references" not in result + + +class TestSearchJobs: + """Tests for search_jobs with job ID extraction and pagination.""" + + @pytest.fixture(autouse=True) + def _set_search_url(self, mock_page): + mock_page.url = "https://www.linkedin.com/jobs/search/?keywords=python" + + async def test_returns_job_ids(self, mock_page): + """search_jobs should return a job_ids list extracted from hrefs.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted("Job 1\nJob 2\nJob 3"), + ), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=["111", "222", "333"], + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=1) + + assert result["job_ids"] == ["111", "222", "333"] + assert "search_results" in result["sections"] + + async def test_returns_references(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted( + "Job 1", + [{"kind": "job", "url": "/jobs/view/111/", "text": "Job 1"}], + ), + ), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=["111"], + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=1) + + assert result["references"] == { + "search_results": [ + {"kind": "job", "url": "/jobs/view/111/", "text": "Job 1"} + ] + } + + async def test_pagination_uses_fixed_page_size(self, mock_page): + """Pages use &start= with fixed 25-per-page offset.""" + extractor = LinkedInExtractor(mock_page) + page1_ids = ["100", "200", "300"] + page2_ids = ["400", "500"] + id_pages = iter([page1_ids, page2_ids]) + text_pages = iter(["Page 1 text", "Page 2 text"]) + urls_visited: list[str] = [] + + async def mock_extract(url, *args, **kwargs): + urls_visited.append(url) + return extracted(next(text_pages)) + + with ( + patch.object(extractor, "_extract_search_page", side_effect=mock_extract), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + side_effect=lambda: next(id_pages), + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=2) + + assert result["job_ids"] == ["100", "200", "300", "400", "500"] + assert len(urls_visited) == 2 + assert "&start=25" in urls_visited[1] + + async def test_deduplication_across_pages(self, mock_page): + """Duplicate job IDs across pages should be deduplicated.""" + extractor = LinkedInExtractor(mock_page) + id_pages = iter([["100", "200"], ["200", "300"]]) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + side_effect=lambda: next(id_pages), + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=2) + + assert result["job_ids"] == ["100", "200", "300"] + assert mock_extract.await_count == 2 + + async def test_early_stop_no_new_ids(self, mock_page): + """Should stop early when a page yields no new job IDs.""" + extractor = LinkedInExtractor(mock_page) + # Page 2 returns same IDs as page 1 + id_pages = iter([["100", "200"], ["100", "200"]]) + extract_call_count = 0 + + async def mock_extract(url, *args, **kwargs): + nonlocal extract_call_count + extract_call_count += 1 + if extract_call_count == 1: + return extracted( + "text", + [{"kind": "job", "url": "/jobs/view/100/", "text": "Job 100"}], + ) + return extracted( + "text", + [{"kind": "job", "url": "/jobs/view/200/", "text": "Job 200"}], + ) + + with ( + patch.object(extractor, "_extract_search_page", side_effect=mock_extract), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + side_effect=lambda: next(id_pages), + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=5) + + assert result["job_ids"] == ["100", "200"] + assert extract_call_count == 2 + assert result["references"] == { + "search_results": [ + {"kind": "job", "url": "/jobs/view/100/", "text": "Job 100"}, + {"kind": "job", "url": "/jobs/view/200/", "text": "Job 200"}, + ] + } + + async def test_stops_at_total_pages(self, mock_page): + """Should stop when total_pages from pagination state is reached.""" + extractor = LinkedInExtractor(mock_page) + # Distinct IDs per page so the no-new-IDs guard never fires + id_pages = iter([["100"], ["200"]]) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + side_effect=lambda: next(id_pages), + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=2, + ) as mock_total_pages, + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=10) + + # Should only visit 2 pages despite max_pages=10 + assert mock_extract.await_count == 2 + assert mock_total_pages.await_count == 1 + assert result["job_ids"] == ["100", "200"] + + async def test_zero_max_pages_fetches_nothing(self, mock_page): + """max_pages=0 should fetch zero pages (validation at tool boundary).""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted("text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=[], + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=0) + + assert result["job_ids"] == [] + assert mock_extract.await_count == 0 + + async def test_single_page(self, mock_page): + """max_pages=1 should only visit one page; filters appear in URL.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted("Job posting text"), + ) as mock_extract, + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=["42"], + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs( + "python", + "Remote", + max_pages=1, + date_posted="past_week", + work_type="remote", + easy_apply=True, + ) + + assert result["job_ids"] == ["42"] + assert "keywords=python" in result["url"] + assert "location=Remote" in result["url"] + assert "f_TPR=r604800" in result["url"] + assert "f_WT=2" in result["url"] + assert "f_EA=true" in result["url"] + assert mock_extract.await_count == 1 + + async def test_page_texts_joined_with_separator(self, mock_page): + """Multiple pages should join text with --- separator.""" + extractor = LinkedInExtractor(mock_page) + text_pages = iter(["Page 1 content", "Page 2 content"]) + id_pages = iter([["100"], ["200"]]) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + side_effect=lambda url, *args, **kwargs: extracted(next(text_pages)), + ) as mock_extract, + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + side_effect=lambda: next(id_pages), + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=2) + + assert "\n---\n" in result["sections"]["search_results"] + assert "Page 1 content" in result["sections"]["search_results"] + assert "Page 2 content" in result["sections"]["search_results"] + assert mock_extract.await_count == 2 + + async def test_empty_results(self, mock_page): + """Should handle empty results gracefully and skip ID extraction.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted(""), + ), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=[], + ) as mock_ids, + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("nonexistent_xyz") + + assert result["job_ids"] == [] + assert result["sections"] == {} + # Empty text should skip ID extraction to avoid stale DOM + mock_ids.assert_not_awaited() + + async def test_no_ids_on_first_page_captures_text(self, mock_page): + """Non-empty text with zero job IDs should be returned in sections.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted("No matching jobs found"), + ), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=[], + ), + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("xyzzy123", max_pages=1) + + assert result["job_ids"] == [] + assert result["sections"]["search_results"] == "No matching jobs found" + + async def test_url_redirect_skips_id_extraction(self, mock_page): + """Unexpected page URL should skip ID extraction but capture text.""" + extractor = LinkedInExtractor(mock_page) + mock_page.url = "https://www.linkedin.com/uas/login" + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted( + "Login page content", + [{"kind": "person", "url": "/in/testuser/", "text": "Test User"}], + ), + ), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=[], + ) as mock_ids, + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=2) + + mock_ids.assert_not_awaited() + assert result["job_ids"] == [] + assert result["sections"]["search_results"] == "Login page content" + assert result["references"] == { + "search_results": [ + {"kind": "person", "url": "/in/testuser/", "text": "Test User"} + ] + } + + async def test_rate_limited_skips_ids_and_text(self, mock_page): + """Rate-limited pages should yield no IDs or text.""" + extractor = LinkedInExtractor(mock_page) + with ( + patch.object( + extractor, + "_extract_search_page", + new_callable=AsyncMock, + return_value=extracted(_RATE_LIMITED_MSG), + ), + patch.object( + extractor, + "_extract_job_ids", + new_callable=AsyncMock, + return_value=["100"], + ) as mock_ids, + patch.object( + extractor, + "_get_total_search_pages", + new_callable=AsyncMock, + return_value=None, + ), + patch( + "linkedin_mcp_server.scraping.extractor.asyncio.sleep", + new_callable=AsyncMock, + ), + ): + result = await extractor.search_jobs("python", max_pages=1) + + assert result["job_ids"] == [] + assert result["sections"] == {} + mock_ids.assert_not_awaited() + + async def test_search_people_omits_orphaned_references(self, mock_page): + extractor = LinkedInExtractor(mock_page) + with patch.object( + extractor, + "extract_page", + new_callable=AsyncMock, + return_value=extracted( + "", + [ + { + "kind": "person", + "url": "/in/testuser/", + "text": "Test User", + } + ], + ), + ): + result = await extractor.search_people("python") + + assert result["sections"] == {} + assert "references" not in result + + +class TestStripLinkedInNoise: + def test_strips_footer(self): + text = "Bill Gates\nChair, Gates Foundation\n\nAbout\nAccessibility\nTalent Solutions\nCareers" + assert strip_linkedin_noise(text) == "Bill Gates\nChair, Gates Foundation" + + def test_strips_footer_with_talent_solutions_variant(self): + text = "Profile content here\n\nAbout\nTalent Solutions\nMore footer" + assert strip_linkedin_noise(text) == "Profile content here" + + def test_strips_sidebar_recommendations(self): + text = "Experience\nCo-chair\nGates Foundation\n\nMore profiles for you\nSundar Pichai\nCEO at Google" + assert strip_linkedin_noise(text) == "Experience\nCo-chair\nGates Foundation" + + def test_strips_premium_upsell(self): + text = "Education\nHarvard University\n\nExplore premium profiles\nRandom Person\nSoftware Engineer" + assert strip_linkedin_noise(text) == "Education\nHarvard University" + + def test_picks_earliest_marker(self): + text = "Content\n\nExplore premium profiles\nStuff\n\nMore profiles for you\nMore stuff\n\nAbout\nAccessibility" + assert strip_linkedin_noise(text) == "Content" + + def test_no_noise_returns_unchanged(self): + text = "Clean content with no LinkedIn chrome" + assert strip_linkedin_noise(text) == "Clean content with no LinkedIn chrome" + + def test_empty_string(self): + assert strip_linkedin_noise("") == "" + + def test_truncate_noise_preserves_media_controls_for_rate_limit_detection(self): + text = "Play\nLoaded: 100.00%\nRemaining time 0:07\nShow captions" + assert _truncate_linkedin_noise(text) == text + assert strip_linkedin_noise(text) == "" + + def test_about_in_profile_content_not_stripped(self): + """'About' followed by actual content (not 'Accessibility') should be preserved.""" + text = "About\nChair of the Gates Foundation.\n\nFeatured\nPost" + assert ( + strip_linkedin_noise(text) + == "About\nChair of the Gates Foundation.\n\nFeatured\nPost" + ) + + def test_real_footer_with_languages(self): + text = ( + "Company info\n\n" + "About\nAccessibility\nTalent Solutions\nCareers\n" + "Select language\nEnglish (English)\nDeutsch (German)" + ) + assert strip_linkedin_noise(text) == "Company info" + + def test_preserves_real_careers_content(self): + text = "Careers\nWe're hiring globally.\nOpen roles in engineering and design." + assert strip_linkedin_noise(text) == text + + def test_preserves_real_questions_content(self): + text = "Questions?\nReach out to our recruiting team for details." + assert strip_linkedin_noise(text) == text + + def test_strips_media_controls_lines(self): + text = ( + "Feed post number 1\n" + "Play\n" + "Loaded: 100.00%\n" + "Remaining time 0:07\n" + "Playback speed\n" + "Actual post content\n" + "Show captions\n" + "Close modal window" + ) + assert strip_linkedin_noise(text) == "Feed post number 1\nActual post content" + + +class TestActivityFeedExtraction: + """Tests for activity page detection and wait behavior in _extract_page_once.""" + + async def test_activity_page_waits_for_content_and_uses_slow_scroll( + self, mock_page + ): + """Activity URLs should call wait_for_function and use slower scroll params.""" + mock_page.evaluate = AsyncMock( + return_value={ + "source": "root", + "text": "Post content " * 50, + "references": [], + } + ) + mock_page.wait_for_function = AsyncMock() + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ) as mock_scroll, + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + result = await extractor._extract_page_once( + "https://www.linkedin.com/in/billgates/recent-activity/all/", + section_name="posts", + ) + + mock_page.wait_for_function.assert_awaited_once() + mock_scroll.assert_awaited_once() + _, kwargs = mock_scroll.call_args + assert kwargs["pause_time"] == 1.0 + assert kwargs["max_scrolls"] == 10 + assert len(result.text) > 200 + + async def test_non_activity_page_skips_wait_and_uses_fast_scroll(self, mock_page): + """Non-activity URLs should not call wait_for_function and use fast scroll.""" + mock_page.evaluate = AsyncMock( + return_value={"source": "root", "text": "Profile text", "references": []} + ) + mock_page.wait_for_function = AsyncMock() + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ) as mock_scroll, + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + await extractor._extract_page_once( + "https://www.linkedin.com/in/billgates/details/experience/", + section_name="experience", + ) + + mock_page.wait_for_function.assert_not_awaited() + mock_scroll.assert_awaited_once() + _, kwargs = mock_scroll.call_args + assert kwargs["pause_time"] == 0.5 + assert kwargs["max_scrolls"] == 5 + + async def test_activity_page_timeout_proceeds_gracefully(self, mock_page): + """When activity feed content never loads, extraction proceeds with available text.""" + from patchright.async_api import TimeoutError as PlaywrightTimeoutError + + tab_headers = "All activity\nPosts\nComments\nVideos\nImages" + mock_page.evaluate = AsyncMock( + return_value={"source": "root", "text": tab_headers, "references": []} + ) + mock_page.wait_for_function = AsyncMock( + side_effect=PlaywrightTimeoutError("Timeout") + ) + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + result = await extractor._extract_page_once( + "https://www.linkedin.com/in/billgates/recent-activity/all/", + section_name="posts", + ) + + # Should return whatever text is available, not crash + assert result.text == tab_headers + + +class TestSearchResultsExtraction: + """Tests for search results page detection and wait behavior in _extract_page_once.""" + + async def test_search_results_page_waits_for_content(self, mock_page): + """Search results URLs should call wait_for_function to wait for content.""" + mock_page.evaluate = AsyncMock( + return_value={ + "source": "root", + "text": "Search results for John Doe. " * 10, + "references": [], + } + ) + mock_page.wait_for_function = AsyncMock() + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + result = await extractor._extract_page_once( + "https://www.linkedin.com/search/results/people/?keywords=John+Doe", + section_name="search_results", + ) + + mock_page.wait_for_function.assert_awaited_once() + assert len(result.text) > 100 + + async def test_non_search_page_does_not_wait_for_search_content(self, mock_page): + """Non-search URLs should not trigger the search results wait.""" + mock_page.evaluate = AsyncMock( + return_value={"source": "root", "text": "Profile text", "references": []} + ) + mock_page.wait_for_function = AsyncMock() + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + await extractor._extract_page_once( + "https://www.linkedin.com/in/billgates/", + section_name="main_profile", + ) + + mock_page.wait_for_function.assert_not_awaited() + + async def test_search_results_timeout_proceeds_gracefully(self, mock_page): + """When search results never load, extraction proceeds with available text.""" + from patchright.async_api import TimeoutError as PlaywrightTimeoutError + + placeholder = "Search results for John Doe. No results found" + mock_page.evaluate = AsyncMock( + return_value={"source": "root", "text": placeholder, "references": []} + ) + mock_page.wait_for_function = AsyncMock( + side_effect=PlaywrightTimeoutError("Timeout") + ) + extractor = LinkedInExtractor(mock_page) + with ( + patch( + "linkedin_mcp_server.scraping.extractor.scroll_to_bottom", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.detect_rate_limit", + new_callable=AsyncMock, + ), + patch( + "linkedin_mcp_server.scraping.extractor.handle_modal_close", + new_callable=AsyncMock, + return_value=False, + ), + ): + result = await extractor._extract_page_once( + "https://www.linkedin.com/search/results/people/?keywords=John+Doe", + section_name="search_results", + ) + + assert result.text == placeholder diff --git a/tests/test_server.py b/tests/test_server.py new file mode 100644 index 00000000..8e9862fd --- /dev/null +++ b/tests/test_server.py @@ -0,0 +1,107 @@ +import asyncio +from unittest.mock import AsyncMock, MagicMock, call + +import mcp.types as mt +from fastmcp import FastMCP +from fastmcp.server.middleware import MiddlewareContext + +from linkedin_mcp_server.config.schema import OAuthConfig +from linkedin_mcp_server.sequential_tool_middleware import ( + SequentialToolExecutionMiddleware, +) +from linkedin_mcp_server.server import create_mcp_server + + +class TestSequentialToolExecutionMiddleware: + async def test_create_mcp_server_registers_sequential_tool_middleware(self): + mcp = create_mcp_server() + + assert any( + isinstance(middleware, SequentialToolExecutionMiddleware) + for middleware in mcp.middleware + ) + + async def test_sequential_tool_middleware_serializes_parallel_tool_calls(self): + mcp = FastMCP("test") + mcp.add_middleware(SequentialToolExecutionMiddleware()) + + active_calls = 0 + max_active_calls = 0 + + @mcp.tool + async def slow_tool(delay: float = 0.05) -> dict[str, float]: + nonlocal active_calls, max_active_calls + active_calls += 1 + max_active_calls = max(max_active_calls, active_calls) + try: + await asyncio.sleep(delay) + return {"delay": delay} + finally: + active_calls -= 1 + + result_one, result_two = await asyncio.gather( + mcp.call_tool("slow_tool", {"delay": 0.05}), + mcp.call_tool("slow_tool", {"delay": 0.05}), + ) + + assert max_active_calls == 1 + assert result_one.structured_content == {"delay": 0.05} + assert result_two.structured_content == {"delay": 0.05} + + async def test_sequential_tool_middleware_preserves_tool_results(self): + mcp = FastMCP("test") + mcp.add_middleware(SequentialToolExecutionMiddleware()) + + @mcp.tool + async def simple_tool(value: int) -> dict[str, int]: + return {"value": value} + + result = await mcp.call_tool("simple_tool", {"value": 7}) + + assert result.structured_content == {"value": 7} + + async def test_sequential_tool_middleware_reports_queue_progress(self): + middleware = SequentialToolExecutionMiddleware() + fastmcp_context = MagicMock() + fastmcp_context.request_context = object() + fastmcp_context.report_progress = AsyncMock() + call_next = AsyncMock(return_value=MagicMock()) + context = MiddlewareContext( + message=mt.CallToolRequestParams(name="slow_tool", arguments={}), + method="tools/call", + fastmcp_context=fastmcp_context, + ) + + await middleware.on_call_tool(context, call_next) + + fastmcp_context.report_progress.assert_has_awaits( + [ + call( + progress=0, + total=100, + message="Queued waiting for scraper lock", + ), + call( + progress=0, + total=100, + message="Scraper lock acquired, starting tool", + ), + ] + ) + + +class TestServerAuth: + async def test_create_mcp_server_no_auth_by_default(self): + mcp = create_mcp_server() + assert mcp.auth is None + + async def test_create_mcp_server_with_oauth(self): + from linkedin_mcp_server.auth import PasswordOAuthProvider + + oauth_config = OAuthConfig( + enabled=True, + base_url="https://example.com", + password="secret", + ) + mcp = create_mcp_server(oauth_config=oauth_config) + assert isinstance(mcp.auth, PasswordOAuthProvider) diff --git a/tests/test_session_state.py b/tests/test_session_state.py new file mode 100644 index 00000000..a077d7cc --- /dev/null +++ b/tests/test_session_state.py @@ -0,0 +1,203 @@ +from linkedin_mcp_server.session_state import ( + get_runtime_id, + load_runtime_state, + load_source_state, + runtime_profile_dir, + runtime_state_path, + runtime_storage_state_path, + source_state_path, + write_runtime_state, + write_source_state, +) + + +def test_write_source_state_creates_generation(monkeypatch, isolate_profile_dir): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.get_runtime_id", + lambda: "macos-arm64-host", + ) + + state = write_source_state(isolate_profile_dir) + + assert state.source_runtime_id == "macos-arm64-host" + assert state.login_generation + assert source_state_path(isolate_profile_dir).exists() + assert load_source_state(isolate_profile_dir) == state + + +def test_write_runtime_state_tracks_source_generation(monkeypatch, isolate_profile_dir): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.get_runtime_id", + lambda: "macos-arm64-host", + ) + source_state = write_source_state(isolate_profile_dir) + + storage_state_path = runtime_storage_state_path( + "linux-amd64-container", + isolate_profile_dir, + ) + storage_state_path.parent.mkdir(parents=True, exist_ok=True) + storage_state_path.write_text("{}") + + runtime_state = write_runtime_state( + "linux-amd64-container", + source_state, + storage_state_path, + isolate_profile_dir, + ) + + assert runtime_state.source_login_generation == source_state.login_generation + assert runtime_state.commit_method == "checkpoint_restart" + assert runtime_state.storage_state_path == str(storage_state_path.resolve()) + assert runtime_state.committed_at + assert runtime_state.profile_path == str( + runtime_profile_dir("linux-amd64-container", isolate_profile_dir).resolve() + ) + assert ( + load_runtime_state("linux-amd64-container", isolate_profile_dir) + == runtime_state + ) + + +def test_load_source_state_ignores_unknown_fields(monkeypatch, isolate_profile_dir): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.get_runtime_id", + lambda: "macos-arm64-host", + ) + state = write_source_state(isolate_profile_dir) + payload = source_state_path(isolate_profile_dir) + payload.write_text( + payload.read_text().replace("}", ', "future_field": "keep calm"}', 1) + ) + + assert load_source_state(isolate_profile_dir) == state + + +def test_load_runtime_state_ignores_unknown_fields(monkeypatch, isolate_profile_dir): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.get_runtime_id", + lambda: "macos-arm64-host", + ) + source_state = write_source_state(isolate_profile_dir) + + storage_state = runtime_storage_state_path( + "linux-amd64-container", + isolate_profile_dir, + ) + storage_state.parent.mkdir(parents=True, exist_ok=True) + storage_state.write_text("{}") + runtime_state = write_runtime_state( + "linux-amd64-container", + source_state, + storage_state, + isolate_profile_dir, + ) + payload = runtime_state_path("linux-amd64-container", isolate_profile_dir) + payload.write_text( + payload.read_text().replace("}", ', "future_field": "still fine"}', 1) + ) + + assert ( + load_runtime_state("linux-amd64-container", isolate_profile_dir) + == runtime_state + ) + + +def test_write_runtime_state_accepts_explicit_created_at( + monkeypatch, isolate_profile_dir +): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.get_runtime_id", + lambda: "macos-arm64-host", + ) + source_state = write_source_state(isolate_profile_dir) + + storage_state_path = runtime_storage_state_path( + "linux-amd64-container", + isolate_profile_dir, + ) + storage_state_path.parent.mkdir(parents=True, exist_ok=True) + storage_state_path.write_text("{}") + + runtime_state = write_runtime_state( + "linux-amd64-container", + source_state, + storage_state_path, + isolate_profile_dir, + created_at="2026-03-12T17:09:00Z", + ) + + assert runtime_state.created_at == "2026-03-12T17:09:00Z" + assert runtime_state.committed_at != runtime_state.created_at + + +def test_runtime_storage_state_path_uses_runtime_dir(isolate_profile_dir): + assert runtime_storage_state_path( + "linux-amd64-container", + isolate_profile_dir, + ) == ( + isolate_profile_dir.parent + / "runtime-profiles" + / "linux-amd64-container" + / "storage-state.json" + ) + + +def test_get_runtime_id_marks_container(monkeypatch): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.platform.system", lambda: "Linux" + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.platform.machine", lambda: "x86_64" + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.Path.exists", + lambda self: str(self) == "/.dockerenv", + ) + + assert get_runtime_id() == "linux-amd64-container" + + +def test_get_runtime_id_marks_container_from_cgroup_v2_mountinfo(monkeypatch): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.platform.system", lambda: "Linux" + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.platform.machine", lambda: "x86_64" + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.Path.exists", + lambda self: str(self) == "/proc/1/mountinfo", + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.Path.read_text", + lambda self, *args, **kwargs: ( + "257 248 0:61 / / rw,relatime - overlay overlay " + "rw,lowerdir=/var/lib/docker/overlay2/l" + ), + ) + + assert get_runtime_id() == "linux-amd64-container" + + +def test_get_runtime_id_ignores_non_root_overlay_mounts(monkeypatch): + monkeypatch.setattr( + "linkedin_mcp_server.session_state.platform.system", lambda: "Linux" + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.platform.machine", lambda: "x86_64" + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.Path.exists", + lambda self: str(self) == "/proc/1/mountinfo", + ) + monkeypatch.setattr( + "linkedin_mcp_server.session_state.Path.read_text", + lambda self, *args, **kwargs: ( + "257 248 0:61 /var/lib/containers/storage/overlay " + "/var/lib/containers/storage/overlay rw,relatime - overlay overlay " + "rw,lowerdir=/var/lib/overlay-host/l" + ), + ) + + assert get_runtime_id() == "linux-amd64-host" diff --git a/tests/test_setup.py b/tests/test_setup.py new file mode 100644 index 00000000..68a6d9f9 --- /dev/null +++ b/tests/test_setup.py @@ -0,0 +1,104 @@ +from types import SimpleNamespace +from unittest.mock import AsyncMock, MagicMock + +import pytest + +from linkedin_mcp_server.session_state import portable_cookie_path +from linkedin_mcp_server.setup import interactive_login + + +class _BrowserContextManager: + def __init__(self, browser): + self.browser = browser + + async def __aenter__(self): + return self.browser + + async def __aexit__(self, exc_type, exc, tb): + return None + + +def _make_browser(*, export_cookies: bool) -> MagicMock: + browser = MagicMock() + browser.page = MagicMock() + browser.page.goto = AsyncMock() + browser.context = MagicMock() + browser.context.cookies = AsyncMock( + return_value=[{"name": "li_at", "domain": ".linkedin.com"}] + ) + browser.export_cookies = AsyncMock(return_value=export_cookies) + return browser + + +@pytest.mark.asyncio +async def test_interactive_login_writes_source_state_when_cookie_export_succeeds( + monkeypatch, tmp_path, capsys +): + browser = _make_browser(export_cookies=True) + write_source_state = MagicMock( + return_value=SimpleNamespace(login_generation="gen-123") + ) + + monkeypatch.setattr( + "linkedin_mcp_server.setup.BrowserManager", + lambda **kwargs: _BrowserContextManager(browser), + ) + monkeypatch.setattr("linkedin_mcp_server.setup.warm_up_browser", AsyncMock()) + monkeypatch.setattr( + "linkedin_mcp_server.setup.resolve_remember_me_prompt", + AsyncMock(return_value=False), + ) + monkeypatch.setattr( + "linkedin_mcp_server.setup.wait_for_manual_login", + AsyncMock(), + ) + monkeypatch.setattr( + "linkedin_mcp_server.setup.write_source_state", write_source_state + ) + monkeypatch.setattr("linkedin_mcp_server.setup.asyncio.sleep", AsyncMock()) + + assert await interactive_login(tmp_path / "profile") is True + + browser.export_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + write_source_state.assert_called_once_with(tmp_path / "profile") + captured = capsys.readouterr() + assert "cookies exported for docker portability" in captured.out.lower() + assert "source session generation: gen-123" in captured.out.lower() + + +@pytest.mark.asyncio +async def test_interactive_login_returns_false_when_cookie_export_fails( + monkeypatch, tmp_path, capsys +): + browser = _make_browser(export_cookies=False) + write_source_state = MagicMock() + + monkeypatch.setattr( + "linkedin_mcp_server.setup.BrowserManager", + lambda **kwargs: _BrowserContextManager(browser), + ) + monkeypatch.setattr("linkedin_mcp_server.setup.warm_up_browser", AsyncMock()) + monkeypatch.setattr( + "linkedin_mcp_server.setup.resolve_remember_me_prompt", + AsyncMock(return_value=False), + ) + monkeypatch.setattr( + "linkedin_mcp_server.setup.wait_for_manual_login", + AsyncMock(), + ) + monkeypatch.setattr( + "linkedin_mcp_server.setup.write_source_state", write_source_state + ) + monkeypatch.setattr("linkedin_mcp_server.setup.asyncio.sleep", AsyncMock()) + + assert await interactive_login(tmp_path / "profile") is False + + browser.export_cookies.assert_awaited_once_with( + portable_cookie_path(tmp_path / "profile") + ) + write_source_state.assert_not_called() + captured = capsys.readouterr() + assert "warning: cookie export failed" in captured.out.lower() + assert "profile saved to" not in captured.out.lower() diff --git a/tests/test_tools.py b/tests/test_tools.py new file mode 100644 index 00000000..857c9a67 --- /dev/null +++ b/tests/test_tools.py @@ -0,0 +1,347 @@ +from typing import Any, Callable, Coroutine +from unittest.mock import AsyncMock, MagicMock + +import pytest +from fastmcp import FastMCP + +from linkedin_mcp_server.scraping.extractor import ExtractedSection, _RATE_LIMITED_MSG + + +async def get_tool_fn( + mcp: FastMCP, name: str +) -> Callable[..., Coroutine[Any, Any, dict[str, Any]]]: + """Extract tool function from FastMCP by name using public API.""" + tool = await mcp.get_tool(name) + if tool is None: + raise ValueError(f"Tool '{name}' not found") + return tool.fn # type: ignore[attr-defined] + + +def _make_mock_extractor(scrape_result: dict) -> MagicMock: + """Create a mock LinkedInExtractor that returns the given result.""" + mock = MagicMock() + mock.scrape_person = AsyncMock(return_value=scrape_result) + mock.scrape_company = AsyncMock(return_value=scrape_result) + mock.scrape_job = AsyncMock(return_value=scrape_result) + mock.search_jobs = AsyncMock(return_value=scrape_result) + mock.search_people = AsyncMock(return_value=scrape_result) + mock.extract_page = AsyncMock( + return_value=ExtractedSection(text="some text", references=[]) + ) + return mock + + +class TestPersonTool: + async def test_get_person_profile_success(self, mock_context): + expected = { + "url": "https://www.linkedin.com/in/test-user/", + "sections": {"main_profile": "John Doe\nSoftware Engineer"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.person import register_person_tools + + mcp = FastMCP("test") + register_person_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_person_profile") + result = await tool_fn("test-user", mock_context, extractor=mock_extractor) + assert result["url"] == "https://www.linkedin.com/in/test-user/" + assert "main_profile" in result["sections"] + assert "pages_visited" not in result + assert "sections_requested" not in result + + async def test_get_person_profile_with_sections(self, mock_context): + """Verify sections parameter is passed through.""" + expected = { + "url": "https://www.linkedin.com/in/test-user/", + "sections": { + "main_profile": "John Doe", + "experience": "Work history", + "contact_info": "Email: test@test.com", + }, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.person import register_person_tools + + mcp = FastMCP("test") + register_person_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_person_profile") + result = await tool_fn( + "test-user", + mock_context, + sections="experience,contact_info", + extractor=mock_extractor, + ) + assert "main_profile" in result["sections"] + assert "experience" in result["sections"] + assert "contact_info" in result["sections"] + # Verify scrape_person was called exactly once with a set[str] + mock_extractor.scrape_person.assert_awaited_once() + call_args = mock_extractor.scrape_person.call_args + assert isinstance(call_args[0][1], set) + assert "experience" in call_args[0][1] + assert "contact_info" in call_args[0][1] + + async def test_get_person_profile_unknown_section(self, mock_context): + expected = { + "url": "https://www.linkedin.com/in/test-user/", + "sections": {"main_profile": "John Doe"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.person import register_person_tools + + mcp = FastMCP("test") + register_person_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_person_profile") + result = await tool_fn( + "test-user", + mock_context, + sections="bogus_section", + extractor=mock_extractor, + ) + assert result["unknown_sections"] == ["bogus_section"] + + async def test_get_person_profile_error(self, mock_context): + from fastmcp.exceptions import ToolError + + from linkedin_mcp_server.exceptions import SessionExpiredError + + mock_extractor = MagicMock() + mock_extractor.scrape_person = AsyncMock(side_effect=SessionExpiredError()) + + from linkedin_mcp_server.tools.person import register_person_tools + + mcp = FastMCP("test") + register_person_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_person_profile") + with pytest.raises(ToolError, match="Session expired"): + await tool_fn("test-user", mock_context, extractor=mock_extractor) + + async def test_get_person_profile_auth_error(self, monkeypatch): + """Auth failures in the DI layer produce proper ToolError responses.""" + from fastmcp.exceptions import ToolError + + from linkedin_mcp_server.core.exceptions import AuthenticationError + + mock_browser = MagicMock() + mock_browser.page = MagicMock() + monkeypatch.setattr( + "linkedin_mcp_server.dependencies.get_or_create_browser", + AsyncMock(return_value=mock_browser), + ) + monkeypatch.setattr( + "linkedin_mcp_server.dependencies.ensure_authenticated", + AsyncMock(side_effect=AuthenticationError("Session expired or invalid.")), + ) + + from linkedin_mcp_server.tools.person import register_person_tools + + mcp = FastMCP("test") + register_person_tools(mcp) + + with pytest.raises(ToolError, match="Authentication failed"): + await mcp.call_tool("get_person_profile", {"linkedin_username": "test"}) + + async def test_search_people(self, mock_context): + expected = { + "url": "https://www.linkedin.com/search/results/people/?keywords=AI+engineer&location=New+York", + "sections": {"search_results": "Jane Doe\nAI Engineer at Acme\nNew York"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.person import register_person_tools + + mcp = FastMCP("test") + register_person_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "search_people") + result = await tool_fn( + "AI engineer", mock_context, location="New York", extractor=mock_extractor + ) + assert "search_results" in result["sections"] + assert "pages_visited" not in result + mock_extractor.search_people.assert_awaited_once_with("AI engineer", "New York") + + +class TestCompanyTools: + async def test_get_company_profile(self, mock_context): + expected = { + "url": "https://www.linkedin.com/company/testcorp/", + "sections": {"about": "TestCorp\nWe build things"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.company import register_company_tools + + mcp = FastMCP("test") + register_company_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_company_profile") + result = await tool_fn("testcorp", mock_context, extractor=mock_extractor) + assert "about" in result["sections"] + assert "pages_visited" not in result + + async def test_get_company_profile_unknown_section(self, mock_context): + expected = { + "url": "https://www.linkedin.com/company/testcorp/", + "sections": {"about": "TestCorp\nWe build things"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.company import register_company_tools + + mcp = FastMCP("test") + register_company_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_company_profile") + result = await tool_fn( + "testcorp", mock_context, sections="bogus", extractor=mock_extractor + ) + assert result["unknown_sections"] == ["bogus"] + + async def test_get_company_posts(self, mock_context): + mock_extractor = MagicMock() + mock_extractor.extract_page = AsyncMock( + return_value=ExtractedSection(text="Post 1\nPost 2", references=[]) + ) + + from linkedin_mcp_server.tools.company import register_company_tools + + mcp = FastMCP("test") + register_company_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_company_posts") + result = await tool_fn("testcorp", mock_context, extractor=mock_extractor) + assert "posts" in result["sections"] + assert result["sections"]["posts"] == "Post 1\nPost 2" + assert "pages_visited" not in result + assert "sections_requested" not in result + + async def test_get_company_posts_omits_rate_limited_sentinel(self, mock_context): + mock_extractor = MagicMock() + mock_extractor.extract_page = AsyncMock( + return_value=ExtractedSection(text=_RATE_LIMITED_MSG, references=[]) + ) + + from linkedin_mcp_server.tools.company import register_company_tools + + mcp = FastMCP("test") + register_company_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_company_posts") + result = await tool_fn("testcorp", mock_context, extractor=mock_extractor) + assert result["sections"] == {} + + async def test_get_company_posts_returns_section_errors(self, mock_context): + mock_extractor = MagicMock() + mock_extractor.extract_page = AsyncMock( + return_value=ExtractedSection( + text="", + references=[], + error={"issue_template_path": "/tmp/company-posts-issue.md"}, + ) + ) + + from linkedin_mcp_server.tools.company import register_company_tools + + mcp = FastMCP("test") + register_company_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_company_posts") + result = await tool_fn("testcorp", mock_context, extractor=mock_extractor) + assert result["sections"] == {} + assert result["section_errors"]["posts"]["issue_template_path"] == ( + "/tmp/company-posts-issue.md" + ) + + async def test_get_company_posts_omits_orphaned_references(self, mock_context): + mock_extractor = MagicMock() + mock_extractor.extract_page = AsyncMock( + return_value=ExtractedSection( + text="", + references=[ + { + "kind": "company", + "url": "/company/testcorp/", + "text": "TestCorp", + } + ], + ) + ) + + from linkedin_mcp_server.tools.company import register_company_tools + + mcp = FastMCP("test") + register_company_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_company_posts") + result = await tool_fn("testcorp", mock_context, extractor=mock_extractor) + assert result["sections"] == {} + assert "references" not in result + + +class TestJobTools: + async def test_get_job_details(self, mock_context): + expected = { + "url": "https://www.linkedin.com/jobs/view/12345/", + "sections": {"job_posting": "Software Engineer\nGreat opportunity"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.job import register_job_tools + + mcp = FastMCP("test") + register_job_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "get_job_details") + result = await tool_fn("12345", mock_context, extractor=mock_extractor) + assert "job_posting" in result["sections"] + assert "pages_visited" not in result + + async def test_search_jobs(self, mock_context): + expected = { + "url": "https://www.linkedin.com/jobs/search/?keywords=python", + "sections": {"search_results": "Job 1\nJob 2"}, + } + mock_extractor = _make_mock_extractor(expected) + + from linkedin_mcp_server.tools.job import register_job_tools + + mcp = FastMCP("test") + register_job_tools(mcp) + + tool_fn = await get_tool_fn(mcp, "search_jobs") + result = await tool_fn( + "python", mock_context, location="Remote", extractor=mock_extractor + ) + assert "search_results" in result["sections"] + assert "pages_visited" not in result + + +class TestToolTimeouts: + async def test_all_tools_have_global_timeout(self): + from linkedin_mcp_server.constants import TOOL_TIMEOUT_SECONDS + from linkedin_mcp_server.server import create_mcp_server + + mcp = create_mcp_server() + + tool_names = ( + "get_person_profile", + "search_people", + "get_company_profile", + "get_company_posts", + "get_job_details", + "search_jobs", + "close_session", + ) + + for name in tool_names: + tool = await mcp.get_tool(name) + assert tool is not None + assert tool.timeout == TOOL_TIMEOUT_SECONDS diff --git a/uv.lock b/uv.lock index dcb60157..0c2018a2 100644 --- a/uv.lock +++ b/uv.lock @@ -1,202 +1,754 @@ version = 1 -revision = 1 +revision = 3 requires-python = ">=3.12" +[[package]] +name = "aiofile" +version = "3.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "caio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/25/da1f0b4dd970e52bf5a36c204c107e11a0c6d3ed195eba0bfbc664c312b2/aiofile-3.9.0-py3-none-any.whl", hash = "sha256:ce2f6c1571538cbdfa0143b04e16b208ecb0e9cb4148e528af8a640ed51cc8aa", size = 19539, upload-time = "2024-10-08T10:39:32.955Z" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +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, upload-time = "2025-03-12T01:42:48.764Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" }, + { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" }, + { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" }, + { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" }, + { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" }, + { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" }, + { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" }, + { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" }, + { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" }, + { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" }, + { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" }, + { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" }, + { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" }, + { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" }, + { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" }, + { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" }, + { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" }, + { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" }, + { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" }, + { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" }, + { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" }, + { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" }, + { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" }, + { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" }, + { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" }, + { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" }, + { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" }, + { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" }, + { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" }, + { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" }, + { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" }, + { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" }, + { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" }, + { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" }, + { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" }, + { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" }, + { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" }, + { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" }, + { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" }, + { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" }, + { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" }, + { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" }, + { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + [[package]] name = "annotated-types" version = "0.7.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, ] [[package]] name = "ansicon" version = "1.89.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/e2/1c866404ddbd280efedff4a9f15abfe943cb83cde6e895022370f3a61f85/ansicon-1.89.0.tar.gz", hash = "sha256:e4d039def5768a47e4afec8e89e83ec3ae5a26bf00ad851f914d1240b444d2b1", size = 67312 } +sdist = { url = "https://files.pythonhosted.org/packages/b6/e2/1c866404ddbd280efedff4a9f15abfe943cb83cde6e895022370f3a61f85/ansicon-1.89.0.tar.gz", hash = "sha256:e4d039def5768a47e4afec8e89e83ec3ae5a26bf00ad851f914d1240b444d2b1", size = 67312, upload-time = "2019-04-29T20:23:57.314Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/75/f9/f1c10e223c7b56a38109a3f2eb4e7fe9a757ea3ed3a166754fb30f65e466/ansicon-1.89.0-py2.py3-none-any.whl", hash = "sha256:f1def52d17f65c2c9682cf8370c03f541f410c1752d6a14029f97318e4b9dfec", size = 63675 }, + { url = "https://files.pythonhosted.org/packages/75/f9/f1c10e223c7b56a38109a3f2eb4e7fe9a757ea3ed3a166754fb30f65e466/ansicon-1.89.0-py2.py3-none-any.whl", hash = "sha256:f1def52d17f65c2c9682cf8370c03f541f410c1752d6a14029f97318e4b9dfec", size = 63675, upload-time = "2019-04-29T20:23:53.83Z" }, ] [[package]] name = "anyio" -version = "4.9.0" +version = "4.12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "idna" }, - { name = "sniffio" }, { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949 } +sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916 }, + { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" }, ] [[package]] name = "attrs" -version = "25.3.0" +version = "25.4.0" 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/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } 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/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, +] + +[[package]] +name = "authlib" +version = "1.6.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/98/00d3dd826d46959ad8e32af2dbb2398868fd9fd0683c26e56d0789bd0e68/authlib-1.6.9.tar.gz", hash = "sha256:d8f2421e7e5980cc1ddb4e32d3f5fa659cfaf60d8eaf3281ebed192e4ab74f04", size = 165134, upload-time = "2026-03-02T07:44:01.998Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/53/23/b65f568ed0c22f1efacb744d2db1a33c8068f384b8c9b482b52ebdbc3ef6/authlib-1.6.9-py2.py3-none-any.whl", hash = "sha256:f08b4c14e08f0861dc18a32357b33fbcfd2ea86cfe3fe149484b4d764c4a0ac3", size = 244197, upload-time = "2026-03-02T07:44:00.307Z" }, +] + +[[package]] +name = "beartype" +version = "0.22.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/94/1009e248bbfbab11397abca7193bea6626806be9a327d399810d523a07cb/beartype-0.22.9.tar.gz", hash = "sha256:8f82b54aa723a2848a56008d18875f91c1db02c32ef6a62319a002e3e25a975f", size = 1608866, upload-time = "2025-12-13T06:50:30.72Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/cc/18245721fa7747065ab478316c7fea7c74777d07f37ae60db2e84f8172e8/beartype-0.22.9-py3-none-any.whl", hash = "sha256:d16c9bbc61ea14637596c5f6fbff2ee99cbe3573e46a716401734ef50c3060c2", size = 1333658, upload-time = "2025-12-13T06:50:28.266Z" }, ] [[package]] name = "blessed" -version = "1.20.0" +version = "1.32.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jinxed", marker = "sys_platform == 'win32'" }, - { name = "six" }, { name = "wcwidth" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/25/ae/92e9968ad23205389ec6bd82e2d4fca3817f1cdef34e10aa8d529ef8b1d7/blessed-1.20.0.tar.gz", hash = "sha256:2cdd67f8746e048f00df47a2880f4d6acbcdb399031b604e34ba8f71d5787680", size = 6655612 } +sdist = { url = "https://files.pythonhosted.org/packages/e6/0c/658dea9ba35fcea19e6feaa8ba0d2dbf8cac9aeaa1f9ab1d77d36f534757/blessed-1.32.0.tar.gz", hash = "sha256:d4090e9908cf86bea15a5275845c8bfc69c4c34eb6d22de07c65d26f1e54a918", size = 13979999, upload-time = "2026-02-28T20:59:01.815Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/98/584f211c3a4bb38f2871fa937ee0cc83c130de50c955d6c7e2334dbf4acb/blessed-1.20.0-py2.py3-none-any.whl", hash = "sha256:0c542922586a265e699188e52d5f5ac5ec0dd517e5a1041d90d2bbf23f906058", size = 58372 }, + { url = "https://files.pythonhosted.org/packages/f6/47/de8f185a1f537fdb5117fcde7050472b8cde3561179e9a68e1a566a6e6c6/blessed-1.32.0-py3-none-any.whl", hash = "sha256:c6fdc18838491ebc7f0460234917eff4e172074934f5f80e82672417bd74be70", size = 111172, upload-time = "2026-02-28T20:58:58.59Z" }, ] [[package]] -name = "certifi" -version = "2025.1.31" +name = "cachetools" +version = "7.0.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 } +sdist = { url = "https://files.pythonhosted.org/packages/6c/c7/342b33cc6877eebc6c9bb45cb9f78e170e575839699f6f3cc96050176431/cachetools-7.0.2.tar.gz", hash = "sha256:7e7f09a4ca8b791d8bb4864afc71e9c17e607a28e6839ca1a644253c97dbeae0", size = 36983, upload-time = "2026-03-02T19:45:16.926Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 }, + { url = "https://files.pythonhosted.org/packages/ef/04/4b6968e77c110f12da96fdbfcb39c6557c2e5e81bd7afcf8ed893d5bc588/cachetools-7.0.2-py3-none-any.whl", hash = "sha256:938dcad184827c5e94928c4fd5526e2b46692b7fb1ae94472da9131d0299343c", size = 13793, upload-time = "2026-03-02T19:45:15.495Z" }, ] [[package]] -name = "cffi" -version = "1.17.1" +name = "caio" +version = "0.9.25" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pycparser" }, +sdist = { url = "https://files.pythonhosted.org/packages/92/88/b8527e1b00c1811db339a1df8bd1ae49d146fcea9d6a5c40e3a80aaeb38d/caio-0.9.25.tar.gz", hash = "sha256:16498e7f81d1d0f5a4c0ad3f2540e65fe25691376e0a5bd367f558067113ed10", size = 26781, upload-time = "2025-12-26T15:21:36.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/25/79c98ebe12df31548ba4eaf44db11b7cad6b3e7b4203718335620939083c/caio-0.9.25-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fb7ff95af4c31ad3f03179149aab61097a71fd85e05f89b4786de0359dffd044", size = 36983, upload-time = "2025-12-26T15:21:36.075Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2b/21288691f16d479945968a0a4f2856818c1c5be56881d51d4dac9b255d26/caio-0.9.25-cp312-cp312-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:97084e4e30dfa598449d874c4d8e0c8d5ea17d2f752ef5e48e150ff9d240cd64", size = 82012, upload-time = "2025-12-26T15:22:20.983Z" }, + { url = "https://files.pythonhosted.org/packages/03/c4/8a1b580875303500a9c12b9e0af58cb82e47f5bcf888c2457742a138273c/caio-0.9.25-cp312-cp312-manylinux_2_34_aarch64.whl", hash = "sha256:4fa69eba47e0f041b9d4f336e2ad40740681c43e686b18b191b6c5f4c5544bfb", size = 81502, upload-time = "2026-03-04T22:08:22.381Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/0fe770b8ffc8362c48134d1592d653a81a3d8748d764bec33864db36319d/caio-0.9.25-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:6bebf6f079f1341d19f7386db9b8b1f07e8cc15ae13bfdaff573371ba0575d69", size = 80200, upload-time = "2026-03-04T22:08:23.382Z" }, + { url = "https://files.pythonhosted.org/packages/31/57/5e6ff127e6f62c9f15d989560435c642144aa4210882f9494204bc892305/caio-0.9.25-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d6c2a3411af97762a2b03840c3cec2f7f728921ff8adda53d7ea2315a8563451", size = 36979, upload-time = "2025-12-26T15:21:35.484Z" }, + { url = "https://files.pythonhosted.org/packages/a3/9f/f21af50e72117eb528c422d4276cbac11fb941b1b812b182e0a9c70d19c5/caio-0.9.25-cp313-cp313-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0998210a4d5cd5cb565b32ccfe4e53d67303f868a76f212e002a8554692870e6", size = 81900, upload-time = "2025-12-26T15:22:21.919Z" }, + { url = "https://files.pythonhosted.org/packages/9c/12/c39ae2a4037cb10ad5eb3578eb4d5f8c1a2575c62bba675f3406b7ef0824/caio-0.9.25-cp313-cp313-manylinux_2_34_aarch64.whl", hash = "sha256:1a177d4777141b96f175fe2c37a3d96dec7911ed9ad5f02bac38aaa1c936611f", size = 81523, upload-time = "2026-03-04T22:08:25.187Z" }, + { url = "https://files.pythonhosted.org/packages/22/59/f8f2e950eb4f1a5a3883e198dca514b9d475415cb6cd7b78b9213a0dd45a/caio-0.9.25-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:9ed3cfb28c0e99fec5e208c934e5c157d0866aa9c32aa4dc5e9b6034af6286b7", size = 80243, upload-time = "2026-03-04T22:08:26.449Z" }, + { url = "https://files.pythonhosted.org/packages/69/ca/a08fdc7efdcc24e6a6131a93c85be1f204d41c58f474c42b0670af8c016b/caio-0.9.25-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fab6078b9348e883c80a5e14b382e6ad6aabbc4429ca034e76e730cf464269db", size = 36978, upload-time = "2025-12-26T15:21:41.055Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6c/d4d24f65e690213c097174d26eda6831f45f4734d9d036d81790a27e7b78/caio-0.9.25-cp314-cp314-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:44a6b58e52d488c75cfaa5ecaa404b2b41cc965e6c417e03251e868ecd5b6d77", size = 81832, upload-time = "2025-12-26T15:22:22.757Z" }, + { url = "https://files.pythonhosted.org/packages/87/a4/e534cf7d2d0e8d880e25dd61e8d921ffcfe15bd696734589826f5a2df727/caio-0.9.25-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:628a630eb7fb22381dd8e3c8ab7f59e854b9c806639811fc3f4310c6bd711d79", size = 81565, upload-time = "2026-03-04T22:08:27.483Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ed/bf81aeac1d290017e5e5ac3e880fd56ee15e50a6d0353986799d1bc5cfd5/caio-0.9.25-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:0ba16aa605ccb174665357fc729cf500679c2d94d5f1458a6f0d5ca48f2060a7", size = 80071, upload-time = "2026-03-04T22:08:28.751Z" }, + { url = "https://files.pythonhosted.org/packages/86/93/1f76c8d1bafe3b0614e06b2195784a3765bbf7b0a067661af9e2dd47fc33/caio-0.9.25-py3-none-any.whl", hash = "sha256:06c0bb02d6b929119b1cfbe1ca403c768b2013a369e2db46bfa2a5761cf82e40", size = 19087, upload-time = "2025-12-26T15:22:00.221Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } + +[[package]] +name = "certifi" +version = "2026.2.25" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 }, - { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 }, - { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 }, - { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 }, + { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" }, ] [[package]] -name = "cfgv" -version = "3.4.0" +name = "cffi" +version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114 } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249 }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, ] [[package]] -name = "charset-normalizer" -version = "3.4.1" +name = "cfgv" +version = "3.5.0" source = { registry = "https://pypi.org/simple" } -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/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/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, - { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, - { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, - { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, - { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, - { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, - { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, - { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, - { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, - { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, - { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, - { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, - { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, - { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, ] [[package]] name = "click" -version = "8.1.8" +version = "8.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } +sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, + { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, ] [[package]] name = "colorama" version = "0.4.6" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "coverage" +version = "7.13.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" }, + { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" }, + { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" }, + { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" }, + { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" }, + { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" }, + { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" }, + { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" }, + { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" }, + { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" }, + { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" }, + { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" }, + { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" }, + { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" }, + { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" }, + { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" }, + { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" }, + { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" }, + { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" }, + { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" }, + { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" }, + { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" }, + { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" }, + { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" }, + { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" }, + { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" }, + { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" }, + { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" }, + { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" }, + { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" }, + { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" }, + { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" }, + { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" }, + { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" }, + { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" }, + { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" }, + { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" }, + { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" }, + { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" }, + { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" }, + { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" }, + { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" }, + { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" }, + { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" }, + { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" }, + { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" }, + { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" }, + { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" }, + { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" }, + { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" }, + { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" }, + { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" }, + { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" }, + { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" }, + { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" }, + { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" }, + { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" }, + { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" }, + { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" }, + { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" }, + { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" }, + { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" }, +] + +[[package]] +name = "cryptography" +version = "46.0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" }, + { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" }, + { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" }, + { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" }, + { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" }, + { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" }, + { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" }, + { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" }, + { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" }, + { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" }, + { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" }, + { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" }, + { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" }, + { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" }, + { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" }, + { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" }, + { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" }, + { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" }, + { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" }, + { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" }, + { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" }, + { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" }, + { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" }, + { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" }, + { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" }, + { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" }, + { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" }, + { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" }, + { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" }, + { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" }, + { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" }, + { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" }, + { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" }, + { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" }, + { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" }, + { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" }, +] + +[[package]] +name = "cyclopts" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "docstring-parser" }, + { name = "rich" }, + { name = "rich-rst" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/5c/88a4068c660a096bbe87efc5b7c190080c9e86919c36ec5f092cb08d852f/cyclopts-4.6.0.tar.gz", hash = "sha256:483c4704b953ea6da742e8de15972f405d2e748d19a848a4d61595e8e5360ee5", size = 162724, upload-time = "2026-02-23T15:44:49.286Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/eb/1e8337755a70dc7d7ff10a73dc8f20e9352c9ad6c2256ed863ac95cd3539/cyclopts-4.6.0-py3-none-any.whl", hash = "sha256:0a891cb55bfd79a3cdce024db8987b33316aba11071e5258c21ac12a640ba9f2", size = 200518, upload-time = "2026-02-23T15:44:47.854Z" }, ] [[package]] name = "distlib" -version = "0.3.9" +version = "0.4.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923 } +sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973 }, + { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, +] + +[[package]] +name = "dnspython" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" }, +] + +[[package]] +name = "docutils" +version = "0.22.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" }, ] [[package]] name = "editor" -version = "1.6.6" +version = "1.7.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "runs" }, { name = "xmod" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2a/92/734a4ab345914259cb6146fd36512608ea42be16195375c379046f33283d/editor-1.6.6.tar.gz", hash = "sha256:bb6989e872638cd119db9a4fce284cd8e13c553886a1c044c6b8d8a160c871f8", size = 3197 } +sdist = { url = "https://files.pythonhosted.org/packages/d9/4f/00e0b75d86bb1e6a943c08942619e3f31de54a0dce3b33b14ae3c2af2dc0/editor-1.7.0.tar.gz", hash = "sha256:979b25e3f7e0386af4478e7392ecb99e6c16a42db7c4336d6b16658fa0449fb3", size = 2355, upload-time = "2026-02-03T13:51:30.717Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/b5/f566c215c58d7d2b8d39104b6cda00f31a18bb480486cb7f0d68de6131f9/editor-1.7.0-py3-none-any.whl", hash = "sha256:8b1ad5e99846b076b96b18f7bc39ae21952c8e20d375c3f8f98fd02cacf19367", size = 3383, upload-time = "2026-02-03T13:51:29.075Z" }, +] + +[[package]] +name = "email-validator" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dnspython" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "execnet" +version = "2.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/c2/4bc8cd09b14e28ce3f406a8b05761bed0d785d1ca8c2a5c6684d884c66a2/editor-1.6.6-py3-none-any.whl", hash = "sha256:e818e6913f26c2a81eadef503a2741d7cca7f235d20e217274a009ecd5a74abf", size = 4017 }, + { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" }, +] + +[[package]] +name = "fastmcp" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "authlib" }, + { name = "cyclopts" }, + { name = "exceptiongroup" }, + { name = "httpx" }, + { name = "jsonref" }, + { name = "jsonschema-path" }, + { name = "mcp" }, + { name = "openapi-pydantic" }, + { name = "opentelemetry-api" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] }, + { name = "pydantic", extra = ["email"] }, + { name = "pyperclip" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "uncalled-for" }, + { name = "uvicorn" }, + { name = "watchfiles" }, + { name = "websockets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/70/862026c4589441f86ad3108f05bfb2f781c6b322ad60a982f40b303b47d7/fastmcp-3.1.0.tar.gz", hash = "sha256:e25264794c734b9977502a51466961eeecff92a0c2f3b49c40c070993628d6d0", size = 17347083, upload-time = "2026-03-03T02:43:11.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/07/516f5b20d88932e5a466c2216b628e5358a71b3a9f522215607c3281de05/fastmcp-3.1.0-py3-none-any.whl", hash = "sha256:b1f73b56fd3b0cb2bd9e2a144fc650d5cc31587ed129d996db7710e464ae8010", size = 633749, upload-time = "2026-03-03T02:43:09.06Z" }, ] [[package]] name = "filelock" -version = "3.18.0" +version = "3.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/77/18/a1fd2231c679dcb9726204645721b12498aeac28e1ad0601038f94b42556/filelock-3.25.0.tar.gz", hash = "sha256:8f00faf3abf9dc730a1ffe9c354ae5c04e079ab7d3a683b7c32da5dd05f26af3", size = 40158, upload-time = "2026-03-01T15:08:45.916Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/0b/de6f54d4a8bedfe8645c41497f3c18d749f0bd3218170c667bf4b81d0cdd/filelock-3.25.0-py3-none-any.whl", hash = "sha256:5ccf8069f7948f494968fc0713c10e5c182a9c9d9eef3a636307a20c2490f047", size = 26427, upload-time = "2026-03-01T15:08:44.593Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0a/10/c23352565a6544bdc5353e0b15fc1c563352101f30e24bf500207a54df9a/filelock-3.18.0.tar.gz", hash = "sha256:adbc88eabb99d2fec8c9c1b229b171f18afa655400173ddc653d5d01501fb9f2", size = 18075 } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215 }, + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "greenlet" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/51/1664f6b78fc6ebbd98019a1fd730e83fa78f2db7058f72b1463d3612b8db/greenlet-3.3.2.tar.gz", hash = "sha256:2eaf067fc6d886931c7962e8c6bede15d2f01965560f3359b27c80bde2d151f2", size = 188267, upload-time = "2026-02-20T20:54:15.531Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:ac8d61d4343b799d1e526db579833d72f23759c71e07181c2d2944e429eb09cd", size = 280358, upload-time = "2026-02-20T20:17:43.971Z" }, + { url = "https://files.pythonhosted.org/packages/a5/23/0eae412a4ade4e6623ff7626e38998cb9b11e9ff1ebacaa021e4e108ec15/greenlet-3.3.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ceec72030dae6ac0c8ed7591b96b70410a8be370b6a477b1dbc072856ad02bd", size = 601217, upload-time = "2026-02-20T20:47:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/f8/16/5b1678a9c07098ecb9ab2dd159fafaf12e963293e61ee8d10ecb55273e5e/greenlet-3.3.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2a5be83a45ce6188c045bcc44b0ee037d6a518978de9a5d97438548b953a1ac", size = 611792, upload-time = "2026-02-20T20:55:58.423Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c5/cc09412a29e43406eba18d61c70baa936e299bc27e074e2be3806ed29098/greenlet-3.3.2-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ae9e21c84035c490506c17002f5c8ab25f980205c3e61ddb3a2a2a2e6c411fcb", size = 626250, upload-time = "2026-02-20T21:02:46.596Z" }, + { url = "https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e99d1749147ac21dde49b99c9abffcbc1e2d55c67501465ef0930d6e78e070", size = 613875, upload-time = "2026-02-20T20:21:01.102Z" }, + { url = "https://files.pythonhosted.org/packages/fc/dd/845f249c3fcd69e32df80cdab059b4be8b766ef5830a3d0aa9d6cad55beb/greenlet-3.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4c956a19350e2c37f2c48b336a3afb4bff120b36076d9d7fb68cb44e05d95b79", size = 1571467, upload-time = "2026-02-20T20:49:33.495Z" }, + { url = "https://files.pythonhosted.org/packages/2a/50/2649fe21fcc2b56659a452868e695634722a6655ba245d9f77f5656010bf/greenlet-3.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c6f8ba97d17a1e7d664151284cb3315fc5f8353e75221ed4324f84eb162b395", size = 1640001, upload-time = "2026-02-20T20:21:09.154Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/cc802e067d02af8b60b6771cea7d57e21ef5e6659912814babb42b864713/greenlet-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:34308836d8370bddadb41f5a7ce96879b72e2fdfb4e87729330c6ab52376409f", size = 231081, upload-time = "2026-02-20T20:17:28.121Z" }, + { url = "https://files.pythonhosted.org/packages/58/2e/fe7f36ff1982d6b10a60d5e0740c759259a7d6d2e1dc41da6d96de32fff6/greenlet-3.3.2-cp312-cp312-win_arm64.whl", hash = "sha256:d3a62fa76a32b462a97198e4c9e99afb9ab375115e74e9a83ce180e7a496f643", size = 230331, upload-time = "2026-02-20T20:17:23.34Z" }, + { url = "https://files.pythonhosted.org/packages/ac/48/f8b875fa7dea7dd9b33245e37f065af59df6a25af2f9561efa8d822fde51/greenlet-3.3.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:aa6ac98bdfd716a749b84d4034486863fd81c3abde9aa3cf8eff9127981a4ae4", size = 279120, upload-time = "2026-02-20T20:19:01.9Z" }, + { url = "https://files.pythonhosted.org/packages/49/8d/9771d03e7a8b1ee456511961e1b97a6d77ae1dea4a34a5b98eee706689d3/greenlet-3.3.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab0c7e7901a00bc0a7284907273dc165b32e0d109a6713babd04471327ff7986", size = 603238, upload-time = "2026-02-20T20:47:32.873Z" }, + { url = "https://files.pythonhosted.org/packages/59/0e/4223c2bbb63cd5c97f28ffb2a8aee71bdfb30b323c35d409450f51b91e3e/greenlet-3.3.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d248d8c23c67d2291ffd47af766e2a3aa9fa1c6703155c099feb11f526c63a92", size = 614219, upload-time = "2026-02-20T20:55:59.817Z" }, + { url = "https://files.pythonhosted.org/packages/94/2b/4d012a69759ac9d77210b8bfb128bc621125f5b20fc398bce3940d036b1c/greenlet-3.3.2-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccd21bb86944ca9be6d967cf7691e658e43417782bce90b5d2faeda0ff78a7dd", size = 628268, upload-time = "2026-02-20T21:02:48.024Z" }, + { url = "https://files.pythonhosted.org/packages/7a/34/259b28ea7a2a0c904b11cd36c79b8cef8019b26ee5dbe24e73b469dea347/greenlet-3.3.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6997d360a4e6a4e936c0f9625b1c20416b8a0ea18a8e19cabbefc712e7397ab", size = 616774, upload-time = "2026-02-20T20:21:02.454Z" }, + { url = "https://files.pythonhosted.org/packages/0a/03/996c2d1689d486a6e199cb0f1cf9e4aa940c500e01bdf201299d7d61fa69/greenlet-3.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64970c33a50551c7c50491671265d8954046cb6e8e2999aacdd60e439b70418a", size = 1571277, upload-time = "2026-02-20T20:49:34.795Z" }, + { url = "https://files.pythonhosted.org/packages/d9/c4/2570fc07f34a39f2caf0bf9f24b0a1a0a47bc2e8e465b2c2424821389dfc/greenlet-3.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1a9172f5bf6bd88e6ba5a84e0a68afeac9dc7b6b412b245dd64f52d83c81e55b", size = 1640455, upload-time = "2026-02-20T20:21:10.261Z" }, + { url = "https://files.pythonhosted.org/packages/91/39/5ef5aa23bc545aa0d31e1b9b55822b32c8da93ba657295840b6b34124009/greenlet-3.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:a7945dd0eab63ded0a48e4dcade82939783c172290a7903ebde9e184333ca124", size = 230961, upload-time = "2026-02-20T20:16:58.461Z" }, + { url = "https://files.pythonhosted.org/packages/62/6b/a89f8456dcb06becff288f563618e9f20deed8dd29beea14f9a168aef64b/greenlet-3.3.2-cp313-cp313-win_arm64.whl", hash = "sha256:394ead29063ee3515b4e775216cb756b2e3b4a7e55ae8fd884f17fa579e6b327", size = 230221, upload-time = "2026-02-20T20:17:37.152Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ae/8bffcbd373b57a5992cd077cbe8858fff39110480a9d50697091faea6f39/greenlet-3.3.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:8d1658d7291f9859beed69a776c10822a0a799bc4bfe1bd4272bb60e62507dab", size = 279650, upload-time = "2026-02-20T20:18:00.783Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c0/45f93f348fa49abf32ac8439938726c480bd96b2a3c6f4d949ec0124b69f/greenlet-3.3.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18cb1b7337bca281915b3c5d5ae19f4e76d35e1df80f4ad3c1a7be91fadf1082", size = 650295, upload-time = "2026-02-20T20:47:34.036Z" }, + { url = "https://files.pythonhosted.org/packages/b3/de/dd7589b3f2b8372069ab3e4763ea5329940fc7ad9dcd3e272a37516d7c9b/greenlet-3.3.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2e47408e8ce1c6f1ceea0dffcdf6ebb85cc09e55c7af407c99f1112016e45e9", size = 662163, upload-time = "2026-02-20T20:56:01.295Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ac/85804f74f1ccea31ba518dcc8ee6f14c79f73fe36fa1beba38930806df09/greenlet-3.3.2-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e3cb43ce200f59483eb82949bf1835a99cf43d7571e900d7c8d5c62cdf25d2f9", size = 675371, upload-time = "2026-02-20T21:02:49.664Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d8/09bfa816572a4d83bccd6750df1926f79158b1c36c5f73786e26dbe4ee38/greenlet-3.3.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63d10328839d1973e5ba35e98cccbca71b232b14051fd957b6f8b6e8e80d0506", size = 664160, upload-time = "2026-02-20T20:21:04.015Z" }, + { url = "https://files.pythonhosted.org/packages/48/cf/56832f0c8255d27f6c35d41b5ec91168d74ec721d85f01a12131eec6b93c/greenlet-3.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e4ab3cfb02993c8cc248ea73d7dae6cec0253e9afa311c9b37e603ca9fad2ce", size = 1619181, upload-time = "2026-02-20T20:49:36.052Z" }, + { url = "https://files.pythonhosted.org/packages/0a/23/b90b60a4aabb4cec0796e55f25ffbfb579a907c3898cd2905c8918acaa16/greenlet-3.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94ad81f0fd3c0c0681a018a976e5c2bd2ca2d9d94895f23e7bb1af4e8af4e2d5", size = 1687713, upload-time = "2026-02-20T20:21:11.684Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ca/2101ca3d9223a1dc125140dbc063644dca76df6ff356531eb27bc267b446/greenlet-3.3.2-cp314-cp314-win_amd64.whl", hash = "sha256:8c4dd0f3997cf2512f7601563cc90dfb8957c0cff1e3a1b23991d4ea1776c492", size = 232034, upload-time = "2026-02-20T20:20:08.186Z" }, + { url = "https://files.pythonhosted.org/packages/f6/4a/ecf894e962a59dea60f04877eea0fd5724618da89f1867b28ee8b91e811f/greenlet-3.3.2-cp314-cp314-win_arm64.whl", hash = "sha256:cd6f9e2bbd46321ba3bbb4c8a15794d32960e3b0ae2cc4d49a1a53d314805d71", size = 231437, upload-time = "2026-02-20T20:18:59.722Z" }, + { url = "https://files.pythonhosted.org/packages/98/6d/8f2ef704e614bcf58ed43cfb8d87afa1c285e98194ab2cfad351bf04f81e/greenlet-3.3.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:e26e72bec7ab387ac80caa7496e0f908ff954f31065b0ffc1f8ecb1338b11b54", size = 286617, upload-time = "2026-02-20T20:19:29.856Z" }, + { url = "https://files.pythonhosted.org/packages/5e/0d/93894161d307c6ea237a43988f27eba0947b360b99ac5239ad3fe09f0b47/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b466dff7a4ffda6ca975979bab80bdadde979e29fc947ac3be4451428d8b0e4", size = 655189, upload-time = "2026-02-20T20:47:35.742Z" }, + { url = "https://files.pythonhosted.org/packages/f5/2c/d2d506ebd8abcb57386ec4f7ba20f4030cbe56eae541bc6fd6ef399c0b41/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8bddc5b73c9720bea487b3bffdb1840fe4e3656fba3bd40aa1489e9f37877ff", size = 658225, upload-time = "2026-02-20T20:56:02.527Z" }, + { url = "https://files.pythonhosted.org/packages/d1/67/8197b7e7e602150938049d8e7f30de1660cfb87e4c8ee349b42b67bdb2e1/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:59b3e2c40f6706b05a9cd299c836c6aa2378cabe25d021acd80f13abf81181cf", size = 666581, upload-time = "2026-02-20T21:02:51.526Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/3a09155fbf728673a1dea713572d2d31159f824a37c22da82127056c44e4/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26b0f4428b871a751968285a1ac9648944cea09807177ac639b030bddebcea4", size = 657907, upload-time = "2026-02-20T20:21:05.259Z" }, + { url = "https://files.pythonhosted.org/packages/f3/fd/d05a4b7acd0154ed758797f0a43b4c0962a843bedfe980115e842c5b2d08/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1fb39a11ee2e4d94be9a76671482be9398560955c9e568550de0224e41104727", size = 1618857, upload-time = "2026-02-20T20:49:37.309Z" }, + { url = "https://files.pythonhosted.org/packages/6f/e1/50ee92a5db521de8f35075b5eff060dd43d39ebd46c2181a2042f7070385/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:20154044d9085151bc309e7689d6f7ba10027f8f5a8c0676ad398b951913d89e", size = 1680010, upload-time = "2026-02-20T20:21:13.427Z" }, + { url = "https://files.pythonhosted.org/packages/29/4b/45d90626aef8e65336bed690106d1382f7a43665e2249017e9527df8823b/greenlet-3.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c04c5e06ec3e022cbfe2cd4a846e1d4e50087444f875ff6d2c2ad8445495cf1a", size = 237086, upload-time = "2026-02-20T20:20:45.786Z" }, ] [[package]] name = "h11" -version = "0.14.0" +version = "0.16.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, ] [[package]] name = "httpcore" -version = "1.0.8" +version = "1.0.9" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "certifi" }, { name = "h11" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9f/45/ad3e1b4d448f22c0cff4f5692f5ed0666658578e358b8d58a19846048059/httpcore-1.0.8.tar.gz", hash = "sha256:86e94505ed24ea06514883fd44d2bc02d90e77e7979c8eb71b90f41d364a1bad", size = 85385 } +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/18/8d/f052b1e336bb2c1fc7ed1aaed898aa570c0b61a09707b108979d9fc6e308/httpcore-1.0.8-py3-none-any.whl", hash = "sha256:5254cf149bcb5f75e9d1b2b9f729ea4a4b883d1ad7379fc632b727cec23674be", size = 78732 }, + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, ] [[package]] @@ -209,50 +761,113 @@ dependencies = [ { name = "httpcore" }, { name = "idna" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, ] [[package]] name = "httpx-sse" -version = "0.4.0" +version = "0.4.3" 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/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" } 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/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" }, ] [[package]] name = "identify" -version = "2.6.9" +version = "2.6.17" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9b/98/a71ab060daec766acc30fb47dfca219d03de34a70d616a79a38c6066c5bf/identify-2.6.9.tar.gz", hash = "sha256:d40dfe3142a1421d8518e3d3985ef5ac42890683e32306ad614a29490abeb6bf", size = 99249 } +sdist = { url = "https://files.pythonhosted.org/packages/57/84/376a3b96e5a8d33a7aa2c5b3b31a4b3c364117184bf0b17418055f6ace66/identify-2.6.17.tar.gz", hash = "sha256:f816b0b596b204c9fdf076ded172322f2723cf958d02f9c3587504834c8ff04d", size = 99579, upload-time = "2026-03-01T20:04:12.702Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/07/ce/0845144ed1f0e25db5e7a79c2354c1da4b5ce392b8966449d5db8dca18f1/identify-2.6.9-py2.py3-none-any.whl", hash = "sha256:c98b4322da415a8e5a70ff6e51fbc2d2932c015532d77e9f8537b4ba7813b150", size = 99101 }, + { url = "https://files.pythonhosted.org/packages/40/66/71c1227dff78aaeb942fed29dd5651f2aec166cc7c9aeea3e8b26a539b7d/identify-2.6.17-py2.py3-none-any.whl", hash = "sha256:be5f8412d5ed4b20f2bd41a65f920990bdccaa6a4a18a08f1eefdcd0bdd885f0", size = 99382, upload-time = "2026-03-01T20:04:11.439Z" }, ] [[package]] name = "idna" -version = "3.10" +version = "3.11" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "8.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, ] [[package]] name = "inquirer" -version = "3.4.0" +version = "3.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "blessed" }, { name = "editor" }, { name = "readchar" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f3/06/ef91eb8f3feafb736aa33dcb278fc9555d17861aa571b684715d095db24d/inquirer-3.4.0.tar.gz", hash = "sha256:8edc99c076386ee2d2204e5e3653c2488244e82cb197b2d498b3c1b5ffb25d0b", size = 14472 } +sdist = { url = "https://files.pythonhosted.org/packages/c1/79/165579fdcd3c2439503732ae76394bf77f5542f3dd18135b60e808e4813c/inquirer-3.4.1.tar.gz", hash = "sha256:60d169fddffe297e2f8ad54ab33698249ccfc3fc377dafb1e5cf01a0efb9cbe5", size = 14069, upload-time = "2025-08-02T18:36:27.901Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/b2/be907c8c0f8303bc4b10089f5470014c3bf3521e9b8d3decf3037fd94725/inquirer-3.4.0-py3-none-any.whl", hash = "sha256:bb0ec93c833e4ce7b51b98b1644b0a4d2bb39755c39787f6a504e4fee7a11b60", size = 18077 }, + { url = "https://files.pythonhosted.org/packages/f0/fd/7c404169a3e04a908df0644893a331f253a7f221961f2b6c0cf44430ae5a/inquirer-3.4.1-py3-none-any.whl", hash = "sha256:717bf146d547b595d2495e7285fd55545cff85e5ce01decc7487d2ec6a605412", size = 18152, upload-time = "2025-08-02T18:36:26.753Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/9c/a788f5bb29c61e456b8ee52ce76dbdd32fd72cd73dd67bc95f42c7a8d13c/jaraco_context-6.1.0.tar.gz", hash = "sha256:129a341b0a85a7db7879e22acd66902fda67882db771754574338898b2d5d86f", size = 15850, upload-time = "2026-01-13T02:53:53.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/48/aa685dbf1024c7bd82bede569e3a85f82c32fd3d79ba5fea578f0159571a/jaraco_context-6.1.0-py3-none-any.whl", hash = "sha256:a43b5ed85815223d0d3cfdb6d7ca0d2bc8946f28f30b6f3216bda070f68badda", size = 7065, upload-time = "2026-01-13T02:53:53.031Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943, upload-time = "2025-12-21T09:29:43.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481, upload-time = "2025-12-21T09:29:42.27Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, ] [[package]] @@ -262,201 +877,367 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ansicon", marker = "sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/20/d0/59b2b80e7a52d255f9e0ad040d2e826342d05580c4b1d7d7747cfb8db731/jinxed-1.3.0.tar.gz", hash = "sha256:1593124b18a41b7a3da3b078471442e51dbad3d77b4d4f2b0c26ab6f7d660dbf", size = 80981 } +sdist = { url = "https://files.pythonhosted.org/packages/20/d0/59b2b80e7a52d255f9e0ad040d2e826342d05580c4b1d7d7747cfb8db731/jinxed-1.3.0.tar.gz", hash = "sha256:1593124b18a41b7a3da3b078471442e51dbad3d77b4d4f2b0c26ab6f7d660dbf", size = 80981, upload-time = "2024-07-31T22:39:18.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/e3/0e0014d6ab159d48189e92044ace13b1e1fe9aa3024ba9f4e8cf172aa7c2/jinxed-1.3.0-py2.py3-none-any.whl", hash = "sha256:b993189f39dc2d7504d802152671535b06d380b26d78070559551cbf92df4fc5", size = 33085, upload-time = "2024-07-31T22:39:17.426Z" }, +] + +[[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, upload-time = "2023-01-16T16:10:04.455Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/27/e3/0e0014d6ab159d48189e92044ace13b1e1fe9aa3024ba9f4e8cf172aa7c2/jinxed-1.3.0-py2.py3-none-any.whl", hash = "sha256:b993189f39dc2d7504d802152671535b06d380b26d78070559551cbf92df4fc5", size = 33085 }, + { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" }, ] [[package]] -name = "linkedin-mcp-server" -version = "0.1.0" -source = { virtual = "." } +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx" }, + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[[package]] +name = "jsonschema-path" +version = "0.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pathable" }, + { name = "pyyaml" }, + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/8a/7e6102f2b8bdc6705a9eb5294f8f6f9ccd3a8420e8e8e19671d1dd773251/jsonschema_path-0.4.5.tar.gz", hash = "sha256:c6cd7d577ae290c7defd4f4029e86fdb248ca1bd41a07557795b3c95e5144918", size = 15113, upload-time = "2026-03-03T09:56:46.87Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/d5/4e96c44f6c1ea3d812cf5391d81a4f5abaa540abf8d04ecd7f66e0ed11df/jsonschema_path-0.4.5-py3-none-any.whl", hash = "sha256:7d77a2c3f3ec569a40efe5c5f942c44c1af2a6f96fe0866794c9ef5b8f87fd65", size = 19368, upload-time = "2026-03-03T09:56:45.39Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "linkedin-scraper-mcp" +version = "4.4.1" +source = { editable = "." } +dependencies = [ + { name = "fastmcp" }, { name = "inquirer" }, - { name = "linkedin-scraper" }, - { name = "mcp", extra = ["cli"] }, - { name = "mypy" }, + { name = "patchright" }, + { name = "python-dotenv" }, +] + +[package.dev-dependencies] +dev = [ + { name = "aiohttp" }, { name = "pre-commit" }, - { name = "pyperclip" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "pytest-cov" }, + { name = "pytest-xdist" }, + { name = "ruff" }, + { name = "ty" }, ] [package.metadata] requires-dist = [ - { name = "httpx", specifier = ">=0.28.1" }, + { name = "fastmcp", specifier = ">=3.0.0" }, { name = "inquirer", specifier = ">=3.4.0" }, - { name = "linkedin-scraper", git = "https://github.com/stickerdaniel/linkedin_scraper.git" }, - { name = "mcp", extras = ["cli"], specifier = ">=1.6.0" }, - { name = "mypy", specifier = ">=1.15.0" }, + { name = "patchright", specifier = ">=1.40.0" }, + { name = "python-dotenv", specifier = ">=1.1.1" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "aiohttp", specifier = ">=3.12.13" }, { name = "pre-commit", specifier = ">=4.2.0" }, - { name = "pyperclip", specifier = ">=1.9.0" }, -] - -[[package]] -name = "linkedin-scraper" -version = "2.11.5" -source = { git = "https://github.com/stickerdaniel/linkedin_scraper.git#23ee0ece83c2ed2b97e697ead2aadc4708e8fa8a" } -dependencies = [ - { name = "lxml" }, - { name = "requests" }, - { name = "selenium" }, -] - -[[package]] -name = "lxml" -version = "5.3.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/80/61/d3dc048cd6c7be6fe45b80cedcbdd4326ba4d550375f266d9f4246d0f4bc/lxml-5.3.2.tar.gz", hash = "sha256:773947d0ed809ddad824b7b14467e1a481b8976e87278ac4a730c2f7c7fcddc1", size = 3679948 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/7e/c749257a7fabc712c4df57927b0f703507f316e9f2c7e3219f8f76d36145/lxml-5.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:16b3897691ec0316a1aa3c6585f61c8b7978475587c5b16fc1d2c28d283dc1b0", size = 8193212 }, - { url = "https://files.pythonhosted.org/packages/a8/50/17e985ba162c9f1ca119f4445004b58f9e5ef559ded599b16755e9bfa260/lxml-5.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a8d4b34a0eeaf6e73169dcfd653c8d47f25f09d806c010daf074fba2db5e2d3f", size = 4451439 }, - { url = "https://files.pythonhosted.org/packages/c2/b5/4960ba0fcca6ce394ed4a2f89ee13083e7fcbe9641a91166e8e9792fedb1/lxml-5.3.2-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9cd7a959396da425022e1e4214895b5cfe7de7035a043bcc2d11303792b67554", size = 5052146 }, - { url = "https://files.pythonhosted.org/packages/5f/d1/184b04481a5d1f5758916de087430752a7b229bddbd6c1d23405078c72bd/lxml-5.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cac5eaeec3549c5df7f8f97a5a6db6963b91639389cdd735d5a806370847732b", size = 4789082 }, - { url = "https://files.pythonhosted.org/packages/7d/75/1a19749d373e9a3d08861addccdf50c92b628c67074b22b8f3c61997cf5a/lxml-5.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29b5f7d77334877c2146e7bb8b94e4df980325fab0a8af4d524e5d43cd6f789d", size = 5312300 }, - { url = "https://files.pythonhosted.org/packages/fb/00/9d165d4060d3f347e63b219fcea5c6a3f9193e9e2868c6801e18e5379725/lxml-5.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:13f3495cfec24e3d63fffd342cc8141355d1d26ee766ad388775f5c8c5ec3932", size = 4836655 }, - { url = "https://files.pythonhosted.org/packages/b8/e9/06720a33cc155966448a19677f079100517b6629a872382d22ebd25e48aa/lxml-5.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e70ad4c9658beeff99856926fd3ee5fde8b519b92c693f856007177c36eb2e30", size = 4961795 }, - { url = "https://files.pythonhosted.org/packages/2d/57/4540efab2673de2904746b37ef7f74385329afd4643ed92abcc9ec6e00ca/lxml-5.3.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:507085365783abd7879fa0a6fa55eddf4bdd06591b17a2418403bb3aff8a267d", size = 4779791 }, - { url = "https://files.pythonhosted.org/packages/99/ad/6056edf6c9f4fa1d41e6fbdae52c733a4a257fd0d7feccfa26ae051bb46f/lxml-5.3.2-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:5bb304f67cbf5dfa07edad904732782cbf693286b9cd85af27059c5779131050", size = 5346807 }, - { url = "https://files.pythonhosted.org/packages/a1/fa/5be91fc91a18f3f705ea5533bc2210b25d738c6b615bf1c91e71a9b2f26b/lxml-5.3.2-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:3d84f5c093645c21c29a4e972b84cb7cf682f707f8706484a5a0c7ff13d7a988", size = 4909213 }, - { url = "https://files.pythonhosted.org/packages/f3/74/71bb96a3b5ae36b74e0402f4fa319df5559a8538577f8c57c50f1b57dc15/lxml-5.3.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:bdc13911db524bd63f37b0103af014b7161427ada41f1b0b3c9b5b5a9c1ca927", size = 4987694 }, - { url = "https://files.pythonhosted.org/packages/08/c2/3953a68b0861b2f97234b1838769269478ccf872d8ea7a26e911238220ad/lxml-5.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1ec944539543f66ebc060ae180d47e86aca0188bda9cbfadff47d86b0dc057dc", size = 4862865 }, - { url = "https://files.pythonhosted.org/packages/e0/9a/52e48f7cfd5a5e61f44a77e679880580dfb4f077af52d6ed5dd97e3356fe/lxml-5.3.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:59d437cc8a7f838282df5a199cf26f97ef08f1c0fbec6e84bd6f5cc2b7913f6e", size = 5423383 }, - { url = "https://files.pythonhosted.org/packages/17/67/42fe1d489e4dcc0b264bef361aef0b929fbb2b5378702471a3043bc6982c/lxml-5.3.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e275961adbd32e15672e14e0cc976a982075208224ce06d149c92cb43db5b93", size = 5286864 }, - { url = "https://files.pythonhosted.org/packages/29/e4/03b1d040ee3aaf2bd4e1c2061de2eae1178fe9a460d3efc1ea7ef66f6011/lxml-5.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:038aeb6937aa404480c2966b7f26f1440a14005cb0702078c173c028eca72c31", size = 5056819 }, - { url = "https://files.pythonhosted.org/packages/83/b3/e2ec8a6378e4d87da3af9de7c862bcea7ca624fc1a74b794180c82e30123/lxml-5.3.2-cp312-cp312-win32.whl", hash = "sha256:3c2c8d0fa3277147bff180e3590be67597e17d365ce94beb2efa3138a2131f71", size = 3486177 }, - { url = "https://files.pythonhosted.org/packages/d5/8a/6a08254b0bab2da9573735725caab8302a2a1c9b3818533b41568ca489be/lxml-5.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:77809fcd97dfda3f399102db1794f7280737b69830cd5c961ac87b3c5c05662d", size = 3817134 }, - { url = "https://files.pythonhosted.org/packages/19/fe/904fd1b0ba4f42ed5a144fcfff7b8913181892a6aa7aeb361ee783d441f8/lxml-5.3.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:77626571fb5270ceb36134765f25b665b896243529eefe840974269b083e090d", size = 8173598 }, - { url = "https://files.pythonhosted.org/packages/97/e8/5e332877b3ce4e2840507b35d6dbe1cc33b17678ece945ba48d2962f8c06/lxml-5.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:78a533375dc7aa16d0da44af3cf6e96035e484c8c6b2b2445541a5d4d3d289ee", size = 4441586 }, - { url = "https://files.pythonhosted.org/packages/de/f4/8fe2e6d8721803182fbce2325712e98f22dbc478126070e62731ec6d54a0/lxml-5.3.2-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a6f62b2404b3f3f0744bbcabb0381c5fe186fa2a9a67ecca3603480f4846c585", size = 5038447 }, - { url = "https://files.pythonhosted.org/packages/a6/ac/fa63f86a1a4b1ba8b03599ad9e2f5212fa813223ac60bfe1155390d1cc0c/lxml-5.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ea918da00091194526d40c30c4996971f09dacab032607581f8d8872db34fbf", size = 4783583 }, - { url = "https://files.pythonhosted.org/packages/1a/7a/08898541296a02c868d4acc11f31a5839d80f5b21d4a96f11d4c0fbed15e/lxml-5.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c35326f94702a7264aa0eea826a79547d3396a41ae87a70511b9f6e9667ad31c", size = 5305684 }, - { url = "https://files.pythonhosted.org/packages/0b/be/9a6d80b467771b90be762b968985d3de09e0d5886092238da65dac9c1f75/lxml-5.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e3bef90af21d31c4544bc917f51e04f94ae11b43156356aff243cdd84802cbf2", size = 4830797 }, - { url = "https://files.pythonhosted.org/packages/8d/1c/493632959f83519802637f7db3be0113b6e8a4e501b31411fbf410735a75/lxml-5.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:52fa7ba11a495b7cbce51573c73f638f1dcff7b3ee23697467dc063f75352a69", size = 4950302 }, - { url = "https://files.pythonhosted.org/packages/c7/13/01aa3b92a6b93253b90c061c7527261b792f5ae7724b420cded733bfd5d6/lxml-5.3.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ad131e2c4d2c3803e736bb69063382334e03648de2a6b8f56a878d700d4b557d", size = 4775247 }, - { url = "https://files.pythonhosted.org/packages/60/4a/baeb09fbf5c84809e119c9cf8e2e94acec326a9b45563bf5ae45a234973b/lxml-5.3.2-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:00a4463ca409ceacd20490a893a7e08deec7870840eff33dc3093067b559ce3e", size = 5338824 }, - { url = "https://files.pythonhosted.org/packages/69/c7/a05850f169ad783ed09740ac895e158b06d25fce4b13887a8ac92a84d61c/lxml-5.3.2-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:87e8d78205331cace2b73ac8249294c24ae3cba98220687b5b8ec5971a2267f1", size = 4899079 }, - { url = "https://files.pythonhosted.org/packages/de/48/18ca583aba5235582db0e933ed1af6540226ee9ca16c2ee2d6f504fcc34a/lxml-5.3.2-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:bf6389133bb255e530a4f2f553f41c4dd795b1fbb6f797aea1eff308f1e11606", size = 4978041 }, - { url = "https://files.pythonhosted.org/packages/b6/55/6968ddc88554209d1dba0dca196360c629b3dfe083bc32a3370f9523a0c4/lxml-5.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b3709fc752b42fb6b6ffa2ba0a5b9871646d97d011d8f08f4d5b3ee61c7f3b2b", size = 4859761 }, - { url = "https://files.pythonhosted.org/packages/2e/52/d2d3baa1e0b7d04a729613160f1562f466fb1a0e45085a33acb0d6981a2b/lxml-5.3.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:abc795703d0de5d83943a4badd770fbe3d1ca16ee4ff3783d7caffc252f309ae", size = 5418209 }, - { url = "https://files.pythonhosted.org/packages/d3/50/6005b297ba5f858a113d6e81ccdb3a558b95a615772e7412d1f1cbdf22d7/lxml-5.3.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:98050830bb6510159f65d9ad1b8aca27f07c01bb3884ba95f17319ccedc4bcf9", size = 5274231 }, - { url = "https://files.pythonhosted.org/packages/fb/33/6f40c09a5f7d7e7fcb85ef75072e53eba3fbadbf23e4991ca069ab2b1abb/lxml-5.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6ba465a91acc419c5682f8b06bcc84a424a7aa5c91c220241c6fd31de2a72bc6", size = 5051899 }, - { url = "https://files.pythonhosted.org/packages/8b/3a/673bc5c0d5fb6596ee2963dd016fdaefaed2c57ede82c7634c08cbda86c1/lxml-5.3.2-cp313-cp313-win32.whl", hash = "sha256:56a1d56d60ea1ec940f949d7a309e0bff05243f9bd337f585721605670abb1c1", size = 3485315 }, - { url = "https://files.pythonhosted.org/packages/8c/be/cab8dd33b0dbe3af5b5d4d24137218f79ea75d540f74eb7d8581195639e0/lxml-5.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:1a580dc232c33d2ad87d02c8a3069d47abbcdce974b9c9cc82a79ff603065dbe", size = 3814639 }, + { name = "pytest", specifier = ">=8.3.5" }, + { name = "pytest-asyncio", specifier = ">=1.0.0" }, + { name = "pytest-cov", specifier = ">=6.1.1" }, + { name = "pytest-xdist", specifier = ">=3.8.0" }, + { name = "ruff", specifier = ">=0.11.11" }, + { name = "ty", specifier = ">=0.0.1a12" }, ] [[package]] name = "markdown-it-py" -version = "3.0.0" +version = "4.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "mdurl" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } 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 }, + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, ] [[package]] name = "mcp" -version = "1.6.0" +version = "1.26.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, { name = "httpx" }, { name = "httpx-sse" }, + { name = "jsonschema" }, { name = "pydantic" }, { name = "pydantic-settings" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, { name = "sse-starlette" }, { name = "starlette" }, - { name = "uvicorn" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/95/d2/f587cb965a56e992634bebc8611c5b579af912b74e04eb9164bd49527d21/mcp-1.6.0.tar.gz", hash = "sha256:d9324876de2c5637369f43161cd71eebfd803df5a95e46225cab8d280e366723", size = 200031 } +sdist = { url = "https://files.pythonhosted.org/packages/fc/6d/62e76bbb8144d6ed86e202b5edd8a4cb631e7c8130f3f4893c3f90262b10/mcp-1.26.0.tar.gz", hash = "sha256:db6e2ef491eecc1a0d93711a76f28dec2e05999f93afd48795da1c1137142c66", size = 608005, upload-time = "2026-01-24T19:40:32.468Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/10/30/20a7f33b0b884a9d14dd3aa94ff1ac9da1479fe2ad66dd9e2736075d2506/mcp-1.6.0-py3-none-any.whl", hash = "sha256:7bd24c6ea042dbec44c754f100984d186620d8b841ec30f1b19eda9b93a634d0", size = 76077 }, -] - -[package.optional-dependencies] -cli = [ - { name = "python-dotenv" }, - { name = "typer" }, + { url = "https://files.pythonhosted.org/packages/fd/d9/eaa1f80170d2b7c5ba23f3b59f766f3a0bb41155fbc32a69adfa1adaaef9/mcp-1.26.0-py3-none-any.whl", hash = "sha256:904a21c33c25aa98ddbeb47273033c435e595bbacfdb177f4bd87f6dceebe1ca", size = 233615, upload-time = "2026-01-24T19:40:30.652Z" }, ] [[package]] name = "mdurl" version = "0.1.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "more-itertools" +version = "10.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ea/5d/38b681d3fce7a266dd9ab73c66959406d565b3e85f21d5e66e1181d93721/more_itertools-10.8.0.tar.gz", hash = "sha256:f638ddf8a1a0d134181275fb5d58b086ead7c6a72429ad725c67503f13ba30bd", size = 137431, upload-time = "2025-09-02T15:23:11.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/8e/469e5a4a2f5855992e425f3cb33804cc07bf18d48f2db061aec61ce50270/more_itertools-10.8.0-py3-none-any.whl", hash = "sha256:52d4362373dcf7c52546bc4af9a86ee7c4579df9a8dc268be0a2f949d376cc9b", size = 69667, upload-time = "2025-09-02T15:23:09.635Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, + { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" }, + { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" }, + { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" }, + { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" }, + { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" }, + { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" }, + { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" }, + { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" }, + { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" }, + { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" }, + { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" }, + { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" }, + { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" }, + { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" }, + { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" }, + { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, ] [[package]] -name = "mypy" -version = "1.15.0" +name = "nodeenv" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, +] + +[[package]] +name = "openapi-pydantic" +version = "0.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mypy-extensions" }, - { name = "typing-extensions" }, + { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 } +sdist = { url = "https://files.pythonhosted.org/packages/02/2e/58d83848dd1a79cb92ed8e63f6ba901ca282c5f09d04af9423ec26c56fd7/openapi_pydantic-0.5.1.tar.gz", hash = "sha256:ff6835af6bde7a459fb93eb93bb92b8749b754fc6e51b2f1590a19dc3005ee0d", size = 60892, upload-time = "2025-01-08T19:29:27.083Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/98/3a/03c74331c5eb8bd025734e04c9840532226775c47a2c39b56a0c8d4f128d/mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd", size = 10793981 }, - { url = "https://files.pythonhosted.org/packages/f0/1a/41759b18f2cfd568848a37c89030aeb03534411eef981df621d8fad08a1d/mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f", size = 9749175 }, - { url = "https://files.pythonhosted.org/packages/12/7e/873481abf1ef112c582db832740f4c11b2bfa510e829d6da29b0ab8c3f9c/mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464", size = 11455675 }, - { url = "https://files.pythonhosted.org/packages/b3/d0/92ae4cde706923a2d3f2d6c39629134063ff64b9dedca9c1388363da072d/mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee", size = 12410020 }, - { url = "https://files.pythonhosted.org/packages/46/8b/df49974b337cce35f828ba6fda228152d6db45fed4c86ba56ffe442434fd/mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e", size = 12498582 }, - { url = "https://files.pythonhosted.org/packages/13/50/da5203fcf6c53044a0b699939f31075c45ae8a4cadf538a9069b165c1050/mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22", size = 9366614 }, - { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592 }, - { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611 }, - { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443 }, - { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541 }, - { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348 }, - { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648 }, - { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 }, + { url = "https://files.pythonhosted.org/packages/12/cf/03675d8bd8ecbf4445504d8071adab19f5f993676795708e36402ab38263/openapi_pydantic-0.5.1-py3-none-any.whl", hash = "sha256:a3a09ef4586f5bd760a8df7f43028b60cafb6d9f61de2acba9574766255ab146", size = 96381, upload-time = "2025-01-08T19:29:25.275Z" }, ] [[package]] -name = "mypy-extensions" -version = "1.0.0" +name = "opentelemetry-api" +version = "1.40.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 } +dependencies = [ + { name = "importlib-metadata" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 }, + { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" }, ] [[package]] -name = "nodeenv" -version = "1.9.1" +name = "packaging" +version = "26.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 } +sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, + { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" }, ] [[package]] -name = "outcome" -version = "1.3.0.post0" +name = "patchright" +version = "1.58.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs" }, + { name = "greenlet" }, + { name = "pyee" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/c6/b1d685ccce237e280d8549454a8b5760e58ab5ee88af9ef875fad2282845/patchright-1.58.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:caadeec5b4812f12db5e245e78b7c1bdd9c6b38d2c15a59fa3047b04e33a3e60", size = 42229561, upload-time = "2026-01-30T15:26:54.532Z" }, + { url = "https://files.pythonhosted.org/packages/61/13/e5726d38be9ecf9ed714346433f2536eb6423748836f4a22a6701b992ba0/patchright-1.58.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:af567d94d2d735be8fa88c6ff9418e46361d823f7b28c10c2823e51942739507", size = 41018089, upload-time = "2026-01-30T15:26:58.097Z" }, + { url = "https://files.pythonhosted.org/packages/6c/33/db35661268edc03381bbf61dcb3119f427591562ce45dce90d17e116ffb5/patchright-1.58.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:ccf8116a97dcef6e3865c9823f51965db069c931346afe5253e25d9486160a92", size = 42229561, upload-time = "2026-01-30T15:27:02.073Z" }, + { url = "https://files.pythonhosted.org/packages/ea/86/98d8f42d5186b6864144fb25e21da8aa7cffa5b9d1d76752276610b9ea58/patchright-1.58.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:832bee2fe48cf9dc07bb3b0f0d05eee923203f348cd98b14c2c515eece326734", size = 46213732, upload-time = "2026-01-30T15:27:06.187Z" }, + { url = "https://files.pythonhosted.org/packages/b9/b1/7094545c805a31235ef69316ccc910aa5ff5e940c41e85df588ca660f00d/patchright-1.58.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:431b1df8967b4919d326a3121445c47f15769bc6a10dcebaa699073eb7d125f9", size = 45942677, upload-time = "2026-01-30T15:27:09.981Z" }, + { url = "https://files.pythonhosted.org/packages/4a/11/e21a51c42969473237c92a47d5433b2c58db1ec2bbd3b340ddeb33ac718f/patchright-1.58.0-py3-none-win32.whl", hash = "sha256:5529f66d296e2894789c309a13750b1a20f468daeb7de511f91bbf54cac95d95", size = 36794461, upload-time = "2026-01-30T15:27:13.409Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a1/b7dff0669ce8814c690c67eee1b44b3cdb422593efbbbbc4bfe3bf10f9fa/patchright-1.58.0-py3-none-win_amd64.whl", hash = "sha256:e37109834056feb8e4e4918fb259d497dbfc37e03f9391c0d3cf1532f5fa9b7f", size = 36794467, upload-time = "2026-01-30T15:27:16.613Z" }, + { url = "https://files.pythonhosted.org/packages/91/2a/81ef2b079bbc925a935f2fd73dc1285c46c7eb35c5032a0d63b48d753c4a/patchright-1.58.0-py3-none-win_arm64.whl", hash = "sha256:b044efea1774beac8ee033583eac7181b86ea450da3a36d3039d7a1a428ac098", size = 33064382, upload-time = "2026-01-30T15:27:19.725Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060 } + +[[package]] +name = "pathable" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/55/b748445cb4ea6b125626f15379be7c96d1035d4fa3e8fee362fa92298abf/pathable-0.5.0.tar.gz", hash = "sha256:d81938348a1cacb525e7c75166270644782c0fb9c8cecc16be033e71427e0ef1", size = 16655, upload-time = "2026-02-20T08:47:00.748Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692 }, + { url = "https://files.pythonhosted.org/packages/52/96/5a770e5c461462575474468e5af931cff9de036e7c2b4fea23c1c58d2cbe/pathable-0.5.0-py3-none-any.whl", hash = "sha256:646e3d09491a6351a0c82632a09c02cdf70a252e73196b36d8a15ba0a114f0a6", size = 16867, upload-time = "2026-02-20T08:46:59.536Z" }, ] [[package]] name = "platformdirs" -version = "4.3.7" +version = "4.9.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/2d/7d512a3913d60623e7eb945c6d1b4f0bddf1d0b7ada5225274c87e5b53d1/platformdirs-4.3.7.tar.gz", hash = "sha256:eb437d586b6a0986388f0d6f74aa0cde27b48d0e3d66843640bfb6bdcdb6e351", size = 21291 } +sdist = { url = "https://files.pythonhosted.org/packages/1b/04/fea538adf7dbbd6d186f551d595961e564a3b6715bdf276b477460858672/platformdirs-4.9.2.tar.gz", hash = "sha256:9a33809944b9db043ad67ca0db94b14bf452cc6aeaac46a88ea55b26e2e9d291", size = 28394, upload-time = "2026-02-16T03:56:10.574Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6d/45/59578566b3275b8fd9157885918fcd0c4d74162928a5310926887b856a51/platformdirs-4.3.7-py3-none-any.whl", hash = "sha256:a03875334331946f13c549dbd8f4bac7a13a50a895a0eb1e8c6a8ace80d40a94", size = 18499 }, + { url = "https://files.pythonhosted.org/packages/48/31/05e764397056194206169869b50cf2fee4dbbbc71b344705b9c0d878d4d8/platformdirs-4.9.2-py3-none-any.whl", hash = "sha256:9170634f126f8efdae22fb58ae8a0eaa86f38365bc57897a6c4f781d1f5875bd", size = 21168, upload-time = "2026-02-16T03:56:08.891Z" }, +] + +[[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, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] [[package]] name = "pre-commit" -version = "4.2.0" +version = "4.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cfgv" }, @@ -465,23 +1246,132 @@ dependencies = [ { name = "pyyaml" }, { name = "virtualenv" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/08/39/679ca9b26c7bb2999ff122d50faa301e49af82ca9c066ec061cfbc0c6784/pre_commit-4.2.0.tar.gz", hash = "sha256:601283b9757afd87d40c4c4a9b2b5de9637a8ea02eaff7adc2d0fb4e04841146", size = 193424 } +sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/74/a88bf1b1efeae488a0c0b7bdf71429c313722d1fc0f377537fbe554e6180/pre_commit-4.2.0-py2.py3-none-any.whl", hash = "sha256:a009ca7205f1eb497d10b845e52c838a98b6cdd2102a6c8e4540e94ee75c58bd", size = 220707 }, + { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" }, +] + +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" }, + { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" }, + { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" }, + { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" }, + { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" }, + { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" }, + { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" }, + { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" }, + { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" }, + { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" }, + { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" }, + { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" }, + { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" }, + { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" }, + { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" }, + { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" }, + { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" }, + { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" }, + { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" }, + { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" }, + { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" }, + { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" }, + { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" }, + { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" }, + { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" }, + { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" }, + { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" }, + { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" }, + { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" }, + { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" }, + { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" }, + { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" }, + { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" }, + { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" }, + { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" }, + { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" }, + { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" }, + { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" }, + { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" }, + { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" }, + { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" }, + { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" }, + { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" }, + { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" }, + { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" }, +] + +[[package]] +name = "py-key-value-aio" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beartype" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/3c/0397c072a38d4bc580994b42e0c90c5f44f679303489e4376289534735e5/py_key_value_aio-0.4.4.tar.gz", hash = "sha256:e3012e6243ed7cc09bb05457bd4d03b1ba5c2b1ca8700096b3927db79ffbbe55", size = 92300, upload-time = "2026-02-16T21:21:43.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/69/f1b537ee70b7def42d63124a539ed3026a11a3ffc3086947a1ca6e861868/py_key_value_aio-0.4.4-py3-none-any.whl", hash = "sha256:18e17564ecae61b987f909fc2cd41ee2012c84b4b1dcb8c055cf8b4bc1bf3f5d", size = 152291, upload-time = "2026-02-16T21:21:44.241Z" }, +] + +[package.optional-dependencies] +filetree = [ + { name = "aiofile" }, + { name = "anyio" }, +] +keyring = [ + { name = "keyring" }, +] +memory = [ + { name = "cachetools" }, ] [[package]] name = "pycparser" -version = "2.22" +version = "3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, ] [[package]] name = "pydantic" -version = "2.11.3" +version = "2.12.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-types" }, @@ -489,395 +1379,833 @@ dependencies = [ { name = "typing-extensions" }, { name = "typing-inspection" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/10/2e/ca897f093ee6c5f3b0bee123ee4465c50e75431c3d5b6a3b44a47134e891/pydantic-2.11.3.tar.gz", hash = "sha256:7471657138c16adad9322fe3070c0116dd6c3ad8d649300e3cbdfe91f4db4ec3", size = 785513 } +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/1d/407b29780a289868ed696d1616f4aad49d6388e5a77f567dcd2629dcd7b8/pydantic-2.11.3-py3-none-any.whl", hash = "sha256:a082753436a07f9ba1289c6ffa01cd93db3548776088aa917cc43b63f68fa60f", size = 443591 }, + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, +] + +[package.optional-dependencies] +email = [ + { name = "email-validator" }, ] [[package]] name = "pydantic-core" -version = "2.33.1" +version = "2.41.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/17/19/ed6a078a5287aea7922de6841ef4c06157931622c89c2a47940837b5eecd/pydantic_core-2.33.1.tar.gz", hash = "sha256:bcc9c6fdb0ced789245b02b7d6603e17d1563064ddcfc36f046b61c0c05dd9df", size = 434395 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c8/ce/3cb22b07c29938f97ff5f5bb27521f95e2ebec399b882392deb68d6c440e/pydantic_core-2.33.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1293d7febb995e9d3ec3ea09caf1a26214eec45b0f29f6074abb004723fc1de8", size = 2026640 }, - { url = "https://files.pythonhosted.org/packages/19/78/f381d643b12378fee782a72126ec5d793081ef03791c28a0fd542a5bee64/pydantic_core-2.33.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:99b56acd433386c8f20be5c4000786d1e7ca0523c8eefc995d14d79c7a081498", size = 1852649 }, - { url = "https://files.pythonhosted.org/packages/9d/2b/98a37b80b15aac9eb2c6cfc6dbd35e5058a352891c5cce3a8472d77665a6/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35a5ec3fa8c2fe6c53e1b2ccc2454398f95d5393ab398478f53e1afbbeb4d939", size = 1892472 }, - { url = "https://files.pythonhosted.org/packages/4e/d4/3c59514e0f55a161004792b9ff3039da52448f43f5834f905abef9db6e4a/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b172f7b9d2f3abc0efd12e3386f7e48b576ef309544ac3a63e5e9cdd2e24585d", size = 1977509 }, - { url = "https://files.pythonhosted.org/packages/a9/b6/c2c7946ef70576f79a25db59a576bce088bdc5952d1b93c9789b091df716/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9097b9f17f91eea659b9ec58148c0747ec354a42f7389b9d50701610d86f812e", size = 2128702 }, - { url = "https://files.pythonhosted.org/packages/88/fe/65a880f81e3f2a974312b61f82a03d85528f89a010ce21ad92f109d94deb/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc77ec5b7e2118b152b0d886c7514a4653bcb58c6b1d760134a9fab915f777b3", size = 2679428 }, - { url = "https://files.pythonhosted.org/packages/6f/ff/4459e4146afd0462fb483bb98aa2436d69c484737feaceba1341615fb0ac/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5e3d15245b08fa4a84cefc6c9222e6f37c98111c8679fbd94aa145f9a0ae23d", size = 2008753 }, - { url = "https://files.pythonhosted.org/packages/7c/76/1c42e384e8d78452ededac8b583fe2550c84abfef83a0552e0e7478ccbc3/pydantic_core-2.33.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ef99779001d7ac2e2461d8ab55d3373fe7315caefdbecd8ced75304ae5a6fc6b", size = 2114849 }, - { url = "https://files.pythonhosted.org/packages/00/72/7d0cf05095c15f7ffe0eb78914b166d591c0eed72f294da68378da205101/pydantic_core-2.33.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:fc6bf8869e193855e8d91d91f6bf59699a5cdfaa47a404e278e776dd7f168b39", size = 2069541 }, - { url = "https://files.pythonhosted.org/packages/b3/69/94a514066bb7d8be499aa764926937409d2389c09be0b5107a970286ef81/pydantic_core-2.33.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:b1caa0bc2741b043db7823843e1bde8aaa58a55a58fda06083b0569f8b45693a", size = 2239225 }, - { url = "https://files.pythonhosted.org/packages/84/b0/e390071eadb44b41f4f54c3cef64d8bf5f9612c92686c9299eaa09e267e2/pydantic_core-2.33.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ec259f62538e8bf364903a7d0d0239447059f9434b284f5536e8402b7dd198db", size = 2248373 }, - { url = "https://files.pythonhosted.org/packages/d6/b2/288b3579ffc07e92af66e2f1a11be3b056fe1214aab314748461f21a31c3/pydantic_core-2.33.1-cp312-cp312-win32.whl", hash = "sha256:e14f369c98a7c15772b9da98987f58e2b509a93235582838bd0d1d8c08b68fda", size = 1907034 }, - { url = "https://files.pythonhosted.org/packages/02/28/58442ad1c22b5b6742b992ba9518420235adced665513868f99a1c2638a5/pydantic_core-2.33.1-cp312-cp312-win_amd64.whl", hash = "sha256:1c607801d85e2e123357b3893f82c97a42856192997b95b4d8325deb1cd0c5f4", size = 1956848 }, - { url = "https://files.pythonhosted.org/packages/a1/eb/f54809b51c7e2a1d9f439f158b8dd94359321abcc98767e16fc48ae5a77e/pydantic_core-2.33.1-cp312-cp312-win_arm64.whl", hash = "sha256:8d13f0276806ee722e70a1c93da19748594f19ac4299c7e41237fc791d1861ea", size = 1903986 }, - { url = "https://files.pythonhosted.org/packages/7a/24/eed3466a4308d79155f1cdd5c7432c80ddcc4530ba8623b79d5ced021641/pydantic_core-2.33.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:70af6a21237b53d1fe7b9325b20e65cbf2f0a848cf77bed492b029139701e66a", size = 2033551 }, - { url = "https://files.pythonhosted.org/packages/ab/14/df54b1a0bc9b6ded9b758b73139d2c11b4e8eb43e8ab9c5847c0a2913ada/pydantic_core-2.33.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:282b3fe1bbbe5ae35224a0dbd05aed9ccabccd241e8e6b60370484234b456266", size = 1852785 }, - { url = "https://files.pythonhosted.org/packages/fa/96/e275f15ff3d34bb04b0125d9bc8848bf69f25d784d92a63676112451bfb9/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b315e596282bbb5822d0c7ee9d255595bd7506d1cb20c2911a4da0b970187d3", size = 1897758 }, - { url = "https://files.pythonhosted.org/packages/b7/d8/96bc536e975b69e3a924b507d2a19aedbf50b24e08c80fb00e35f9baaed8/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1dfae24cf9921875ca0ca6a8ecb4bb2f13c855794ed0d468d6abbec6e6dcd44a", size = 1986109 }, - { url = "https://files.pythonhosted.org/packages/90/72/ab58e43ce7e900b88cb571ed057b2fcd0e95b708a2e0bed475b10130393e/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6dd8ecfde08d8bfadaea669e83c63939af76f4cf5538a72597016edfa3fad516", size = 2129159 }, - { url = "https://files.pythonhosted.org/packages/dc/3f/52d85781406886c6870ac995ec0ba7ccc028b530b0798c9080531b409fdb/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2f593494876eae852dc98c43c6f260f45abdbfeec9e4324e31a481d948214764", size = 2680222 }, - { url = "https://files.pythonhosted.org/packages/f4/56/6e2ef42f363a0eec0fd92f74a91e0ac48cd2e49b695aac1509ad81eee86a/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:948b73114f47fd7016088e5186d13faf5e1b2fe83f5e320e371f035557fd264d", size = 2006980 }, - { url = "https://files.pythonhosted.org/packages/4c/c0/604536c4379cc78359f9ee0aa319f4aedf6b652ec2854953f5a14fc38c5a/pydantic_core-2.33.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e11f3864eb516af21b01e25fac915a82e9ddad3bb0fb9e95a246067398b435a4", size = 2120840 }, - { url = "https://files.pythonhosted.org/packages/1f/46/9eb764814f508f0edfb291a0f75d10854d78113fa13900ce13729aaec3ae/pydantic_core-2.33.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:549150be302428b56fdad0c23c2741dcdb5572413776826c965619a25d9c6bde", size = 2072518 }, - { url = "https://files.pythonhosted.org/packages/42/e3/fb6b2a732b82d1666fa6bf53e3627867ea3131c5f39f98ce92141e3e3dc1/pydantic_core-2.33.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:495bc156026efafd9ef2d82372bd38afce78ddd82bf28ef5276c469e57c0c83e", size = 2248025 }, - { url = "https://files.pythonhosted.org/packages/5c/9d/fbe8fe9d1aa4dac88723f10a921bc7418bd3378a567cb5e21193a3c48b43/pydantic_core-2.33.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ec79de2a8680b1a67a07490bddf9636d5c2fab609ba8c57597e855fa5fa4dacd", size = 2254991 }, - { url = "https://files.pythonhosted.org/packages/aa/99/07e2237b8a66438d9b26482332cda99a9acccb58d284af7bc7c946a42fd3/pydantic_core-2.33.1-cp313-cp313-win32.whl", hash = "sha256:ee12a7be1742f81b8a65b36c6921022301d466b82d80315d215c4c691724986f", size = 1915262 }, - { url = "https://files.pythonhosted.org/packages/8a/f4/e457a7849beeed1e5defbcf5051c6f7b3c91a0624dd31543a64fc9adcf52/pydantic_core-2.33.1-cp313-cp313-win_amd64.whl", hash = "sha256:ede9b407e39949d2afc46385ce6bd6e11588660c26f80576c11c958e6647bc40", size = 1956626 }, - { url = "https://files.pythonhosted.org/packages/20/d0/e8d567a7cff7b04e017ae164d98011f1e1894269fe8e90ea187a3cbfb562/pydantic_core-2.33.1-cp313-cp313-win_arm64.whl", hash = "sha256:aa687a23d4b7871a00e03ca96a09cad0f28f443690d300500603bd0adba4b523", size = 1909590 }, - { url = "https://files.pythonhosted.org/packages/ef/fd/24ea4302d7a527d672c5be06e17df16aabfb4e9fdc6e0b345c21580f3d2a/pydantic_core-2.33.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:401d7b76e1000d0dd5538e6381d28febdcacb097c8d340dde7d7fc6e13e9f95d", size = 1812963 }, - { url = "https://files.pythonhosted.org/packages/5f/95/4fbc2ecdeb5c1c53f1175a32d870250194eb2fdf6291b795ab08c8646d5d/pydantic_core-2.33.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7aeb055a42d734c0255c9e489ac67e75397d59c6fbe60d155851e9782f276a9c", size = 1986896 }, - { url = "https://files.pythonhosted.org/packages/71/ae/fe31e7f4a62431222d8f65a3bd02e3fa7e6026d154a00818e6d30520ea77/pydantic_core-2.33.1-cp313-cp313t-win_amd64.whl", hash = "sha256:338ea9b73e6e109f15ab439e62cb3b78aa752c7fd9536794112e14bee02c8d18", size = 1931810 }, +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, ] [[package]] name = "pydantic-settings" -version = "2.8.1" +version = "2.13.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic" }, { name = "python-dotenv" }, + { name = "typing-inspection" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/88/82/c79424d7d8c29b994fb01d277da57b0a9b09cc03c3ff875f9bd8a86b2145/pydantic_settings-2.8.1.tar.gz", hash = "sha256:d5c663dfbe9db9d5e1c646b2e161da12f0d734d422ee56f567d0ea2cee4e8585", size = 83550 } +sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/53/a64f03044927dc47aafe029c42a5b7aabc38dfb813475e0e1bf71c4a59d0/pydantic_settings-2.8.1-py3-none-any.whl", hash = "sha256:81942d5ac3d905f7f3ee1a70df5dfb62d5569c12f51a5a647defc1c3d9ee2e9c", size = 30839 }, + { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" }, +] + +[[package]] +name = "pyee" +version = "13.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/04/e7c1fe4dc78a6fdbfd6c337b1c3732ff543b8a397683ab38378447baa331/pyee-13.0.1.tar.gz", hash = "sha256:0b931f7c14535667ed4c7e0d531716368715e860b988770fc7eb8578d1f67fc8", size = 31655, upload-time = "2026-02-14T21:12:28.044Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/b4d4827c93ef43c01f599ef31453ccc1c132b353284fc6c87d535c233129/pyee-13.0.1-py3-none-any.whl", hash = "sha256:af2f8fede4171ef667dfded53f96e2ed0d6e6bd7ee3bb46437f77e3b57689228", size = 15659, upload-time = "2026-02-14T21:12:26.263Z" }, ] [[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, upload-time = "2025-06-21T13:39:12.283Z" } 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, upload-time = "2025-06-21T13:39:07.939Z" }, ] [[package]] -name = "pyperclip" -version = "1.9.0" +name = "pyjwt" +version = "2.11.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/30/23/2f0a3efc4d6a32f3b63cdff36cd398d9701d26cda58e3ab97ac79fb5e60d/pyperclip-1.9.0.tar.gz", hash = "sha256:b7de0142ddc81bfc5c7507eea19da920b92252b548b96186caf94a5e2527d310", size = 20961 } +sdist = { url = "https://files.pythonhosted.org/packages/5c/5a/b46fa56bf322901eee5b0454a34343cdbdae202cd421775a8ee4e42fd519/pyjwt-2.11.0.tar.gz", hash = "sha256:35f95c1f0fbe5d5ba6e43f00271c275f7a1a4db1dab27bf708073b75318ea623", size = 98019, upload-time = "2026-01-30T19:59:55.694Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/01/c26ce75ba460d5cd503da9e13b21a33804d38c2165dec7b716d06b13010c/pyjwt-2.11.0-py3-none-any.whl", hash = "sha256:94a6bde30eb5c8e04fee991062b534071fd1439ef58d2adc9ccb823e7bcd0469", size = 28224, upload-time = "2026-01-30T19:59:54.539Z" }, +] + +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, +] [[package]] -name = "pysocks" -version = "1.7.1" +name = "pyperclip" +version = "1.11.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bd/11/293dd436aea955d45fc4e8a35b6ae7270f5b8e00b53cf6c024c83b657a11/PySocks-1.7.1.tar.gz", hash = "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0", size = 284429 } +sdist = { url = "https://files.pythonhosted.org/packages/e8/52/d87eba7cb129b81563019d1679026e7a112ef76855d6159d24754dbd2a51/pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6", size = 12185, upload-time = "2025-09-26T14:40:37.245Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8d/59/b4572118e098ac8e46e399a1dd0f2d85403ce8bbaad9ec79373ed6badaf9/PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5", size = 16725 }, + { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" }, ] [[package]] -name = "python-dotenv" -version = "1.1.0" +name = "pytest" +version = "9.0.2" 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 } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/18/98a99ad95133c6a6e2005fe89faedf294a748bd5dc803008059409ac9b1e/python_dotenv-1.1.0-py3-none-any.whl", hash = "sha256:d7c01d9e2293916c18baf562d95698754b0dbbb5e74d457c45d4f6561fb9d55d", size = 20256 }, + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, ] [[package]] -name = "pyyaml" -version = "6.0.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, - { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, - { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, - { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, - { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, - { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, - { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, - { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, - { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, - { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, - { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, - { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, - { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, - { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, - { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, - { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, - { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, - { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, +name = "pytest-asyncio" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, ] [[package]] -name = "readchar" -version = "4.2.1" +name = "pytest-cov" +version = "7.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/dd/f8/8657b8cbb4ebeabfbdf991ac40eca8a1d1bd012011bd44ad1ed10f5cb494/readchar-4.2.1.tar.gz", hash = "sha256:91ce3faf07688de14d800592951e5575e9c7a3213738ed01d394dcc949b79adb", size = 9685 } +dependencies = [ + { name = "coverage" }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/10/e4b1e0e5b6b6745c8098c275b69bc9d73e9542d5c7da4f137542b499ed44/readchar-4.2.1-py3-none-any.whl", hash = "sha256:a769305cd3994bb5fa2764aa4073452dc105a4ec39068ffe6efd3c20c60acc77", size = 9350 }, + { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" }, ] [[package]] -name = "requests" -version = "2.32.3" +name = "pytest-xdist" +version = "3.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "certifi" }, - { name = "charset-normalizer" }, - { name = "idna" }, - { name = "urllib3" }, + { name = "execnet" }, + { name = "pytest" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, + { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" }, ] [[package]] -name = "rich" -version = "14.0.0" +name = "python-discovery" +version = "1.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markdown-it-py" }, - { name = "pygments" }, + { name = "filelock" }, + { name = "platformdirs" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078 } +sdist = { url = "https://files.pythonhosted.org/packages/82/bb/93a3e83bdf9322c7e21cafd092e56a4a17c4d8ef4277b6eb01af1a540a6f/python_discovery-1.1.0.tar.gz", hash = "sha256:447941ba1aed8cc2ab7ee3cb91be5fc137c5bdbb05b7e6ea62fbdcb66e50b268", size = 55674, upload-time = "2026-02-26T09:42:49.668Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229 }, + { url = "https://files.pythonhosted.org/packages/06/54/82a6e2ef37f0f23dccac604b9585bdcbd0698604feb64807dcb72853693e/python_discovery-1.1.0-py3-none-any.whl", hash = "sha256:a162893b8809727f54594a99ad2179d2ede4bf953e12d4c7abc3cc9cdbd1437b", size = 30687, upload-time = "2026-02-26T09:42:48.548Z" }, ] [[package]] -name = "runs" +name = "python-dotenv" version = "1.2.2" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "xmod" }, +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/26/6d/b9aace390f62db5d7d2c77eafce3d42774f27f1829d24fa9b6f598b3ef71/runs-1.2.2.tar.gz", hash = "sha256:9dc1815e2895cfb3a48317b173b9f1eac9ba5549b36a847b5cc60c3bf82ecef1", size = 5474 } + +[[package]] +name = "python-multipart" +version = "0.0.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/86/d6/17caf2e4af1dec288477a0cbbe4a96fbc9b8a28457dce3f1f452630ce216/runs-1.2.2-py3-none-any.whl", hash = "sha256:0980dcbc25aba1505f307ac4f0e9e92cbd0be2a15a1e983ee86c24c87b839dfd", size = 7033 }, + { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" }, ] [[package]] -name = "selenium" -version = "4.31.0" +name = "pywin32" +version = "311" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "trio" }, - { name = "trio-websocket" }, - { name = "typing-extensions" }, - { name = "urllib3", extra = ["socks"] }, - { name = "websocket-client" }, +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e0/bf/642cce8b5a9edad8e4880fdefbeb24f69bec2086b1121c63f883c412b797/selenium-4.31.0.tar.gz", hash = "sha256:441cffc436a2e6659fe3cfb012692435652efd38b0d368d16f661a5db47825f5", size = 855418 } + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/32/53/212db779d2481b0a8428365960596f8d5a4d482ae12c441d0507fd54aaf2/selenium-4.31.0-py3-none-any.whl", hash = "sha256:7b8b8d5e424d7133cb7aa656263b19ac505ec26d65c0f921a696e7e2c5ccd95b", size = 9350584 }, + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, ] [[package]] -name = "shellingham" -version = "1.5.4" +name = "pyyaml" +version = "6.0.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310 } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755 }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] [[package]] -name = "six" -version = "1.17.0" +name = "readchar" +version = "4.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +sdist = { url = "https://files.pythonhosted.org/packages/dd/f8/8657b8cbb4ebeabfbdf991ac40eca8a1d1bd012011bd44ad1ed10f5cb494/readchar-4.2.1.tar.gz", hash = "sha256:91ce3faf07688de14d800592951e5575e9c7a3213738ed01d394dcc949b79adb", size = 9685, upload-time = "2024-11-04T18:28:07.757Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, + { url = "https://files.pythonhosted.org/packages/a9/10/e4b1e0e5b6b6745c8098c275b69bc9d73e9542d5c7da4f137542b499ed44/readchar-4.2.1-py3-none-any.whl", hash = "sha256:a769305cd3994bb5fa2764aa4073452dc105a4ec39068ffe6efd3c20c60acc77", size = 9350, upload-time = "2024-11-04T18:28:02.859Z" }, ] [[package]] -name = "sniffio" -version = "1.3.1" +name = "referencing" +version = "0.37.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, ] [[package]] -name = "sortedcontainers" -version = "2.4.0" +name = "rich" +version = "14.3.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594 } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 }, + { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" }, ] [[package]] -name = "sse-starlette" -version = "2.2.1" +name = "rich-rst" +version = "1.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio" }, - { name = "starlette" }, + { name = "docutils" }, + { name = "rich" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/71/a4/80d2a11af59fe75b48230846989e93979c892d3a20016b42bb44edb9e398/sse_starlette-2.2.1.tar.gz", hash = "sha256:54470d5f19274aeed6b2d473430b08b4b379ea851d953b11d7f1c4a2c118b419", size = 17376 } +sdist = { url = "https://files.pythonhosted.org/packages/bc/6d/a506aaa4a9eaa945ed8ab2b7347859f53593864289853c5d6d62b77246e0/rich_rst-1.3.2.tar.gz", hash = "sha256:a1196fdddf1e364b02ec68a05e8ff8f6914fee10fbca2e6b6735f166bb0da8d4", size = 14936, upload-time = "2025-10-14T16:49:45.332Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/e0/5b8bd393f27f4a62461c5cf2479c75a2cc2ffa330976f9f00f5f6e4f50eb/sse_starlette-2.2.1-py3-none-any.whl", hash = "sha256:6410a3d3ba0c89e7675d4c273a301d64649c03a5ef1ca101f10b47f895fd0e99", size = 10120 }, + { url = "https://files.pythonhosted.org/packages/13/2f/b4530fbf948867702d0a3f27de4a6aab1d156f406d72852ab902c4d04de9/rich_rst-1.3.2-py3-none-any.whl", hash = "sha256:a99b4907cbe118cf9d18b0b44de272efa61f15117c61e39ebdc431baf5df722a", size = 12567, upload-time = "2025-10-14T16:49:42.953Z" }, ] [[package]] -name = "starlette" -version = "0.46.1" +name = "rpds-py" +version = "0.30.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" }, + { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" }, + { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" }, + { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" }, + { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" }, + { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" }, + { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" }, + { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" }, + { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" }, + { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" }, + { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" }, + { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" }, + { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" }, + { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" }, + { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" }, + { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" }, + { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" }, + { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" }, + { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" }, + { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" }, + { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" }, + { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" }, + { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" }, + { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" }, + { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" }, + { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" }, + { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" }, + { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" }, + { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" }, + { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" }, + { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" }, + { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" }, + { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" }, + { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" }, + { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" }, + { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" }, + { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" }, + { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" }, + { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, + { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, + { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550, upload-time = "2026-02-26T20:04:14.959Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333, upload-time = "2026-02-26T20:04:20.093Z" }, + { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356, upload-time = "2026-02-26T20:04:05.808Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434, upload-time = "2026-02-26T20:03:54.656Z" }, + { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456, upload-time = "2026-02-26T20:03:52.738Z" }, + { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772, upload-time = "2026-02-26T20:04:08.138Z" }, + { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051, upload-time = "2026-02-26T20:04:03.53Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494, upload-time = "2026-02-26T20:04:10.497Z" }, + { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221, upload-time = "2026-02-26T20:04:12.84Z" }, + { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459, upload-time = "2026-02-26T20:04:00.969Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366, upload-time = "2026-02-26T20:03:48.099Z" }, + { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887, upload-time = "2026-02-26T20:03:45.771Z" }, + { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939, upload-time = "2026-02-26T20:04:22.42Z" }, + { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471, upload-time = "2026-02-26T20:03:58.924Z" }, + { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382, upload-time = "2026-02-26T20:04:24.424Z" }, + { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664, upload-time = "2026-02-26T20:03:50.56Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048, upload-time = "2026-02-26T20:04:17.191Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776, upload-time = "2026-02-26T20:03:56.908Z" }, +] + +[[package]] +name = "runs" +version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio" }, + { name = "xmod" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/04/1b/52b27f2e13ceedc79a908e29eac426a63465a1a01248e5f24aa36a62aeb3/starlette-0.46.1.tar.gz", hash = "sha256:3c88d58ee4bd1bb807c0d1acb381838afc7752f9ddaec81bbe4383611d833230", size = 2580102 } +sdist = { url = "https://files.pythonhosted.org/packages/f2/ae/095cb626504733e288a81f871f86b10530b787d77c50193c170daaca0df1/runs-1.3.0.tar.gz", hash = "sha256:cca304b631dbefec598c7bfbcfb50d6feace6d3a968734b67fd42d3c728f5a05", size = 4585, upload-time = "2026-02-03T15:59:58.974Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/4b/528ccf7a982216885a1ff4908e886b8fb5f19862d1962f56a3fce2435a70/starlette-0.46.1-py3-none-any.whl", hash = "sha256:77c74ed9d2720138b25875133f3a2dae6d854af2ec37dceb56aef370c1d8a227", size = 71995 }, + { url = "https://files.pythonhosted.org/packages/4f/b6/049c75d399ccf6e25abea0652b85bf7e7e101e0300aa9c1d284ad7061c0b/runs-1.3.0-py3-none-any.whl", hash = "sha256:e71a551cfa8da9ef882cac1d5a108bda78c9edee5b8d87e37c1003da5b6a7bed", size = 6406, upload-time = "2026-02-03T15:59:59.96Z" }, ] [[package]] -name = "trio" -version = "0.29.0" +name = "secretstorage" +version = "3.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs" }, - { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" }, - { name = "idna" }, - { name = "outcome" }, - { name = "sniffio" }, - { name = "sortedcontainers" }, + { name = "cryptography" }, + { name = "jeepney" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a1/47/f62e62a1a6f37909aed0bf8f5d5411e06fa03846cfcb64540cd1180ccc9f/trio-0.29.0.tar.gz", hash = "sha256:ea0d3967159fc130acb6939a0be0e558e364fee26b5deeecc893a6b08c361bdf", size = 588952 } +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c9/55/c4d9bea8b3d7937901958f65124123512419ab0eb73695e5f382521abbfb/trio-0.29.0-py3-none-any.whl", hash = "sha256:d8c463f1a9cc776ff63e331aba44c125f423a5a13c684307e828d930e625ba66", size = 492920 }, + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, ] [[package]] -name = "trio-websocket" -version = "0.12.2" +name = "sse-starlette" +version = "3.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "outcome" }, - { name = "trio" }, - { name = "wsproto" }, + { name = "anyio" }, + { name = "starlette" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d1/3c/8b4358e81f2f2cfe71b66a267f023a91db20a817b9425dd964873796980a/trio_websocket-0.12.2.tar.gz", hash = "sha256:22c72c436f3d1e264d0910a3951934798dcc5b00ae56fc4ee079d46c7cf20fae", size = 33549 } +sdist = { url = "https://files.pythonhosted.org/packages/5a/9f/c3695c2d2d4ef70072c3a06992850498b01c6bc9be531950813716b426fa/sse_starlette-3.3.2.tar.gz", hash = "sha256:678fca55a1945c734d8472a6cad186a55ab02840b4f6786f5ee8770970579dcd", size = 32326, upload-time = "2026-02-28T11:24:34.36Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/19/eb640a397bba49ba49ef9dbe2e7e5c04202ba045b6ce2ec36e9cadc51e04/trio_websocket-0.12.2-py3-none-any.whl", hash = "sha256:df605665f1db533f4a386c94525870851096a223adcb97f72a07e8b4beba45b6", size = 21221 }, + { url = "https://files.pythonhosted.org/packages/61/28/8cb142d3fe80c4a2d8af54ca0b003f47ce0ba920974e7990fa6e016402d1/sse_starlette-3.3.2-py3-none-any.whl", hash = "sha256:5c3ea3dad425c601236726af2f27689b74494643f57017cafcb6f8c9acfbb862", size = 14270, upload-time = "2026-02-28T11:24:32.984Z" }, ] [[package]] -name = "typer" -version = "0.15.2" +name = "starlette" +version = "0.52.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click" }, - { name = "rich" }, - { name = "shellingham" }, - { name = "typing-extensions" }, + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8b/6f/3991f0f1c7fcb2df31aef28e0594d8d54b05393a0e4e34c65e475c2a5d41/typer-0.15.2.tar.gz", hash = "sha256:ab2fab47533a813c49fe1f16b1a370fd5819099c00b119e0633df65f22144ba5", size = 100711 } +sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7f/fc/5b29fea8cee020515ca82cc68e3b8e1e34bb19a3535ad854cac9257b414c/typer-0.15.2-py3-none-any.whl", hash = "sha256:46a499c6107d645a9c13f7ee46c5d5096cae6f5fc57dd11eccbbb9ae3e44ddfc", size = 45061 }, + { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" }, +] + +[[package]] +name = "ty" +version = "0.0.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/56/95/8de69bb98417227b01f1b1d743c819d6456c9fd140255b6124b05b17dfd6/ty-0.0.20.tar.gz", hash = "sha256:ebba6be7974c14efbb2a9adda6ac59848f880d7259f089dfa72a093039f1dcc6", size = 5262529, upload-time = "2026-03-02T15:51:36.587Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/2c/718abe48393e521bf852cd6b0f984766869b09c258d6e38a118768a91731/ty-0.0.20-py3-none-linux_armv6l.whl", hash = "sha256:7cc12769c169c9709a829c2248ee2826b7aae82e92caeac813d856f07c021eae", size = 10333656, upload-time = "2026-03-02T15:51:56.461Z" }, + { url = "https://files.pythonhosted.org/packages/41/0e/eb1c4cc4a12862e2327b72657bcebb10b7d9f17046f1bdcd6457a0211615/ty-0.0.20-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3b777c1bf13bc0a95985ebb8a324b8668a4a9b2e514dde5ccf09e4d55d2ff232", size = 10168505, upload-time = "2026-03-02T15:51:51.895Z" }, + { url = "https://files.pythonhosted.org/packages/89/7f/10230798e673f0dd3094dfd16e43bfd90e9494e7af6e8e7db516fb431ddf/ty-0.0.20-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b2a4a7db48bf8cba30365001bc2cad7fd13c1a5aacdd704cc4b7925de8ca5eb3", size = 9678510, upload-time = "2026-03-02T15:51:48.451Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3d/59d9159577494edd1728f7db77b51bb07884bd21384f517963114e3ab5f6/ty-0.0.20-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6846427b8b353a43483e9c19936dc6a25612573b44c8f7d983dfa317e7f00d4c", size = 10162926, upload-time = "2026-03-02T15:51:40.558Z" }, + { url = "https://files.pythonhosted.org/packages/9c/a8/b7273eec3e802f78eb913fbe0ce0c16ef263723173e06a5776a8359b2c66/ty-0.0.20-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:245ceef5bd88df366869385cf96411cb14696334f8daa75597cf7e41c3012eb8", size = 10171702, upload-time = "2026-03-02T15:51:44.069Z" }, + { url = "https://files.pythonhosted.org/packages/9f/32/5f1144f2f04a275109db06e3498450c4721554215b80ae73652ef412eeab/ty-0.0.20-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4d21d1cdf67a444d3c37583c17291ddba9382a9871021f3f5d5735e09e85efe", size = 10682552, upload-time = "2026-03-02T15:51:33.102Z" }, + { url = "https://files.pythonhosted.org/packages/6a/db/9f1f637310792f12bd6ed37d5fc8ab39ba1a9b0c6c55a33865e9f1cad840/ty-0.0.20-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bd4ffd907d1bd70e46af9e9a2f88622f215e1bf44658ea43b32c2c0b357299e4", size = 11242605, upload-time = "2026-03-02T15:51:34.895Z" }, + { url = "https://files.pythonhosted.org/packages/1a/68/cc9cae2e732fcfd20ccdffc508407905a023fc8493b8771c392d915528dc/ty-0.0.20-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b6594b58d8b0e9d16a22b3045fc1305db4b132c8d70c17784ab8c7a7cc986807", size = 10974655, upload-time = "2026-03-02T15:51:46.011Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c1/b9e3e3f28fe63486331e653f6aeb4184af8b1fe80542fcf74d2dda40a93d/ty-0.0.20-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3662f890518ce6cf4d7568f57d03906912d2afbf948a01089a28e325b1ef198c", size = 10761325, upload-time = "2026-03-02T15:51:26.818Z" }, + { url = "https://files.pythonhosted.org/packages/39/9e/67db935bdedf219a00fb69ec5437ba24dab66e0f2e706dd54a4eca234b84/ty-0.0.20-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0e3ffbae58f9f0d17cdc4ac6d175ceae560b7ed7d54f9ddfb1c9f31054bcdc2c", size = 10145793, upload-time = "2026-03-02T15:51:38.562Z" }, + { url = "https://files.pythonhosted.org/packages/c7/de/b0eb815d4dc5a819c7e4faddc2a79058611169f7eef07ccc006531ce228c/ty-0.0.20-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:176e52bc8bb00b0e84efd34583962878a447a3a0e34ecc45fd7097a37554261b", size = 10189640, upload-time = "2026-03-02T15:51:50.202Z" }, + { url = "https://files.pythonhosted.org/packages/b8/71/63734923965cbb70df1da3e93e4b8875434e326b89e9f850611122f279bf/ty-0.0.20-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b2bc73025418e976ca4143dde71fb9025a90754a08ac03e6aa9b80d4bed1294b", size = 10370568, upload-time = "2026-03-02T15:51:42.295Z" }, + { url = "https://files.pythonhosted.org/packages/32/a0/a532c2048533347dff48e9ca98bd86d2c224356e101688a8edaf8d6973fb/ty-0.0.20-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:d52f7c9ec6e363e094b3c389c344d5a140401f14a77f0625e3f28c21918552f5", size = 10853999, upload-time = "2026-03-02T15:51:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/48/88/36c652c658fe96658043e4abc8ea97801de6fb6e63ab50aaa82807bff1d8/ty-0.0.20-py3-none-win32.whl", hash = "sha256:c7d32bfe93f8fcaa52b6eef3f1b930fd7da410c2c94e96f7412c30cfbabf1d17", size = 9744206, upload-time = "2026-03-02T15:51:54.183Z" }, + { url = "https://files.pythonhosted.org/packages/ff/a7/a4a13bed1d7fd9d97aaa3c5bb5e6d3e9a689e6984806cbca2ab4c9233cac/ty-0.0.20-py3-none-win_amd64.whl", hash = "sha256:a5e10f40fc4a0a1cbcb740a4aad5c7ce35d79f030836ea3183b7a28f43170248", size = 10711999, upload-time = "2026-03-02T15:51:29.212Z" }, + { url = "https://files.pythonhosted.org/packages/8d/7e/6bfd748a9f4ff9267ed3329b86a0f02cdf6ab49f87bc36c8a164852f99fc/ty-0.0.20-py3-none-win_arm64.whl", hash = "sha256:53f7a5c12c960e71f160b734f328eff9a35d578af4b67a36b0bb5990ac5cdc27", size = 10150143, upload-time = "2026-03-02T15:51:31.283Z" }, ] [[package]] name = "typing-extensions" -version = "4.13.2" +version = "4.15.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967 } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806 }, + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, ] [[package]] name = "typing-inspection" -version = "0.4.0" +version = "0.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/82/5c/e6082df02e215b846b4b8c0b887a64d7d08ffaba30605502639d44c06b82/typing_inspection-0.4.0.tar.gz", hash = "sha256:9765c87de36671694a67904bf2c96e395be9c6439bb6c87b5142569dcdd65122", size = 76222 } +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/31/08/aa4fdfb71f7de5176385bd9e90852eaf6b5d622735020ad600f2bab54385/typing_inspection-0.4.0-py3-none-any.whl", hash = "sha256:50e72559fcd2a6367a19f7a7e610e6afcb9fac940c650290eed893d61386832f", size = 14125 }, + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, ] [[package]] -name = "urllib3" -version = "2.4.0" +name = "uncalled-for" +version = "0.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672 } +sdist = { url = "https://files.pythonhosted.org/packages/02/7c/b5b7d8136f872e3f13b0584e576886de0489d7213a12de6bebf29ff6ebfc/uncalled_for-0.2.0.tar.gz", hash = "sha256:b4f8fdbcec328c5a113807d653e041c5094473dd4afa7c34599ace69ccb7e69f", size = 49488, upload-time = "2026-02-27T17:40:58.137Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680 }, -] - -[package.optional-dependencies] -socks = [ - { name = "pysocks" }, + { url = "https://files.pythonhosted.org/packages/ff/7f/4320d9ce3be404e6310b915c3629fe27bf1e2f438a1a7a3cb0396e32e9a9/uncalled_for-0.2.0-py3-none-any.whl", hash = "sha256:2c0bd338faff5f930918f79e7eb9ff48290df2cb05fcc0b40a7f334e55d4d85f", size = 11351, upload-time = "2026-02-27T17:40:56.804Z" }, ] [[package]] name = "uvicorn" -version = "0.34.0" +version = "0.41.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "h11" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/4b/4d/938bd85e5bf2edeec766267a5015ad969730bb91e31b44021dfe8b22df6c/uvicorn-0.34.0.tar.gz", hash = "sha256:404051050cd7e905de2c9a7e61790943440b3416f49cb409f965d9dcd0fa73e9", size = 76568 } +sdist = { url = "https://files.pythonhosted.org/packages/32/ce/eeb58ae4ac36fe09e3842eb02e0eb676bf2c53ae062b98f1b2531673efdd/uvicorn-0.41.0.tar.gz", hash = "sha256:09d11cf7008da33113824ee5a1c6422d89fbc2ff476540d69a34c87fab8b571a", size = 82633, upload-time = "2026-02-16T23:07:24.1Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/61/14/33a3a1352cfa71812a3a21e8c9bfb83f60b0011f5e36f2b1399d51928209/uvicorn-0.34.0-py3-none-any.whl", hash = "sha256:023dc038422502fa28a09c7a30bf2b6991512da7dcdb8fd35fe57cfc154126f4", size = 62315 }, + { url = "https://files.pythonhosted.org/packages/83/e4/d04a086285c20886c0daad0e026f250869201013d18f81d9ff5eada73a88/uvicorn-0.41.0-py3-none-any.whl", hash = "sha256:29e35b1d2c36a04b9e180d4007ede3bcb32a85fbdfd6c6aeb3f26839de088187", size = 68783, upload-time = "2026-02-16T23:07:22.357Z" }, ] [[package]] name = "virtualenv" -version = "20.30.0" +version = "21.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "distlib" }, { name = "filelock" }, { name = "platformdirs" }, + { name = "python-discovery" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/38/e0/633e369b91bbc664df47dcb5454b6c7cf441e8f5b9d0c250ce9f0546401e/virtualenv-20.30.0.tar.gz", hash = "sha256:800863162bcaa5450a6e4d721049730e7f2dae07720e0902b0e4040bd6f9ada8", size = 4346945 } +sdist = { url = "https://files.pythonhosted.org/packages/2f/c9/18d4b36606d6091844daa3bd93cf7dc78e6f5da21d9f21d06c221104b684/virtualenv-21.1.0.tar.gz", hash = "sha256:1990a0188c8f16b6b9cf65c9183049007375b26aad415514d377ccacf1e4fb44", size = 5840471, upload-time = "2026-02-27T08:49:29.702Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4c/ed/3cfeb48175f0671ec430ede81f628f9fb2b1084c9064ca67ebe8c0ed6a05/virtualenv-20.30.0-py3-none-any.whl", hash = "sha256:e34302959180fca3af42d1800df014b35019490b119eba981af27f2fa486e5d6", size = 4329461 }, + { url = "https://files.pythonhosted.org/packages/78/55/896b06bf93a49bec0f4ae2a6f1ed12bd05c8860744ac3a70eda041064e4d/virtualenv-21.1.0-py3-none-any.whl", hash = "sha256:164f5e14c5587d170cf98e60378eb91ea35bf037be313811905d3a24ea33cc07", size = 5825072, upload-time = "2026-02-27T08:49:27.516Z" }, ] [[package]] -name = "wcwidth" -version = "0.2.13" +name = "watchfiles" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, + { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" }, + { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" }, + { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" }, + { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" }, + { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" }, + { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" }, + { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" }, + { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" }, + { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" }, + { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" }, + { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" }, + { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" }, + { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" }, + { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" }, + { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" }, + { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" }, + { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" }, + { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" }, + { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" }, + { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" }, + { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" }, + { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" }, + { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" }, + { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" }, + { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" }, + { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" }, + { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" }, + { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" }, + { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" }, + { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" }, + { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" }, + { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" }, + { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" }, + { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" }, + { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" }, + { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" }, ] [[package]] -name = "websocket-client" -version = "1.8.0" +name = "wcwidth" +version = "0.6.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648 } +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, + { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" }, ] [[package]] -name = "wsproto" -version = "1.2.0" +name = "websockets" +version = "16.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c9/4a/44d3c295350d776427904d73c189e10aeae66d7f555bb2feee16d1e4ba5a/wsproto-1.2.0.tar.gz", hash = "sha256:ad565f26ecb92588a3e43bc3d96164de84cd9902482b130d0ddbaa9664a85065", size = 53425 } +sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/58/e860788190eba3bcce367f74d29c4675466ce8dddfba85f7827588416f01/wsproto-1.2.0-py3-none-any.whl", hash = "sha256:b9acddd652b585d75b20477888c56642fdade28bdfd3579aa24a4d2c037dd736", size = 24226 }, + { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" }, + { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" }, + { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" }, + { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" }, + { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" }, + { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" }, + { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" }, + { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" }, + { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" }, + { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" }, + { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" }, + { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" }, + { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" }, + { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" }, + { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" }, + { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" }, + { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" }, + { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" }, + { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" }, + { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" }, + { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" }, + { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" }, + { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" }, ] [[package]] name = "xmod" -version = "1.8.1" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/3f/0bc3b89c1dd4dee1f954db4c857f8fbe9cdfa8b25efe370b6d78399a93ac/xmod-1.9.0.tar.gz", hash = "sha256:98b2e7e8e659c51b635f4e98faf3fa1f3f96dab2805f19ddd6e352bbb4d23991", size = 3501, upload-time = "2026-02-03T14:34:48.881Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/a4/74b9510cf2922fb923f6330fd47c049e9e89d984d6dd445c82a85ce7c4e9/xmod-1.9.0-py3-none-any.whl", hash = "sha256:0a549a055e0391a53e356a63552baa7e562560a6e9423c1437cb53b5d4f697a0", size = 4451, upload-time = "2026-02-03T14:34:48.032Z" }, +] + +[[package]] +name = "yarl" +version = "1.23.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/b2/e3edc608823348e628a919e1d7129e641997afadd946febdd704aecc5881/xmod-1.8.1.tar.gz", hash = "sha256:38c76486b9d672c546d57d8035df0beb7f4a9b088bc3fb2de5431ae821444377", size = 3988 } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" }, + { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" }, + { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" }, + { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" }, + { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" }, + { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" }, + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" }, + { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" }, + { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" }, + { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" }, + { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" }, + { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" }, + { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" }, + { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" }, + { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" }, + { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" }, + { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" }, + { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" }, + { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" }, + { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" }, + { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" }, + { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" }, + { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" }, + { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" }, + { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" }, + { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" }, + { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" }, + { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" }, + { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" }, + { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" }, + { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" }, + { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" }, + { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" }, + { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" }, + { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" }, + { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" }, + { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" }, + { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" }, + { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" }, + { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" }, + { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" }, + { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" }, + { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" }, + { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" }, + { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" }, + { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" }, + { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" }, + { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" }, + { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" }, + { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" }, + { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" }, + { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" }, + { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" }, + { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" }, + { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" }, + { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" }, + { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" }, + { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" }, + { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" }, + { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" }, + { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" }, + { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" }, + { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" }, + { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" }, + { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" }, + { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" }, + { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" }, + { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" }, + { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" }, + { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" }, + { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" }, + { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" }, + { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" }, +] + +[[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, upload-time = "2025-06-08T17:06:39.4Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/33/6b/0dc75b64a764ea1cb8e4c32d1fb273c147304d4e5483cd58be482dc62e45/xmod-1.8.1-py3-none-any.whl", hash = "sha256:a24e9458a4853489042522bdca9e50ee2eac5ab75c809a91150a8a7f40670d48", size = 4610 }, + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, ]