diff --git a/.gitignore b/.gitignore index 90901d5faf..34decd349e 100644 --- a/.gitignore +++ b/.gitignore @@ -197,3 +197,9 @@ tmp*/ temp*/ .tmp/ .temp/ + +# GAIA data directories +data_gaia_hub/ +**/data_gaia_hub/ +python/packages/lab/gaia/**/*.jsonl + diff --git a/python/.pre-commit-config.yaml b/python/.pre-commit-config.yaml index 50c73e52e8..b00f87602d 100644 --- a/python/.pre-commit-config.yaml +++ b/python/.pre-commit-config.yaml @@ -7,6 +7,7 @@ repos: - id: check-toml name: Check TOML files files: \.toml$ + exclude: ^python/packages/lab/cookiecutter-agent-framework-lab/ - id: check-yaml name: Check YAML files files: \.yaml$ @@ -17,12 +18,15 @@ repos: - id: end-of-file-fixer name: Fix End of File files: \.py$ + exclude: ^python/packages/lab/cookiecutter-agent-framework-lab/ - id: mixed-line-ending name: Check Mixed Line Endings files: \.py$ + exclude: ^python/packages/lab/cookiecutter-agent-framework-lab/ - id: check-ast name: Check Valid Python Samples types: ["python"] + exclude: ^python/packages/lab/cookiecutter-agent-framework-lab/ - repo: https://github.com/nbQA-dev/nbQA rev: 1.9.1 hooks: @@ -35,6 +39,7 @@ repos: - id: pyupgrade name: Upgrade Python syntax args: [--py310-plus] + exclude: ^python/packages/lab/cookiecutter-agent-framework-lab/ - repo: local hooks: - id: poe-check diff --git a/python/check_md_code_blocks.py b/python/check_md_code_blocks.py index b61bfd2743..32efa0ab92 100644 --- a/python/check_md_code_blocks.py +++ b/python/check_md_code_blocks.py @@ -54,22 +54,27 @@ def extract_python_code_blocks(markdown_file_path: str) -> list[tuple[str, int]] return code_blocks -def check_code_blocks(markdown_file_paths: list[str]) -> None: +def check_code_blocks(markdown_file_paths: list[str], exclude_patterns: list[str] | None = None) -> None: """Check Python code blocks in a Markdown file for syntax errors.""" files_with_errors: list[str] = [] + exclude_patterns = exclude_patterns or [] for markdown_file_path in markdown_file_paths: + # Skip files that match any exclude pattern + if any(pattern in markdown_file_path for pattern in exclude_patterns): + logger.info(f"Skipping {markdown_file_path} (matches exclude pattern)") + continue code_blocks = extract_python_code_blocks(markdown_file_path) had_errors = False for code_block, line_no in code_blocks: markdown_file_path_with_line_no = f"{markdown_file_path}:{line_no}" logger.info("Checking a code block in %s...", markdown_file_path_with_line_no) - # Skip blocks that don't import agent_framework modules - if all( + # Skip blocks that don't import agent_framework modules or import lab modules + if (all( all(import_code not in code_block for import_code in [f"import {module}", f"from {module}"]) for module in ["agent_framework"] - ): + ) or "agent_framework.lab" in code_block): logger.info(f' {with_color("OK[ignored]", Colors.CGREENBG)}') continue @@ -79,7 +84,7 @@ def check_code_blocks(markdown_file_paths: list[str]) -> None: # Run pyright on the temporary file using subprocess.run - result = subprocess.run(["pyright", temp_file.name], capture_output=True, text=True) # nosec + result = subprocess.run(["uv", "run", "pyright", temp_file.name], capture_output=True, text=True, cwd=".") # nosec if result.returncode != 0: highlighted_code = highlight(code_block, PythonLexer(), TerminalFormatter()) # type: ignore logger.info( @@ -109,5 +114,6 @@ if __name__ == "__main__": parser = argparse.ArgumentParser(description="Check code blocks in Markdown files for syntax errors.") # Argument is a list of markdown files containing glob patterns parser.add_argument("markdown_files", nargs="+", help="Markdown files to check.") + parser.add_argument("--exclude", action="append", help="Exclude files containing this pattern.") args = parser.parse_args() - check_code_blocks(args.markdown_files) + check_code_blocks(args.markdown_files, args.exclude) diff --git a/python/packages/lab/README.md b/python/packages/lab/README.md new file mode 100644 index 0000000000..76ac1fa1fb --- /dev/null +++ b/python/packages/lab/README.md @@ -0,0 +1,144 @@ +# Agent Framework Lab + +This directory contains experimental packages for Microsoft Agent Framework that are distributed as separate installable packages under the `agent_framework.lab` namespace. +Lab packages are not part of the core framework and may experience breaking changes or be deprecated in the future. + +## What are Lab Packages? + +Lab packages are extensions to the core Agent Framework that falls into +one of the following categories: + +1. Incubation of new features that may get incorprated by the core framework. +2. Research prototypes built on the core framework. +3. Benchmarks and experimentation tools. + +## Lab Packages + +- [**gaia**](./gaia/): GAIA benchmark implementation (`agent-framework-lab-gaia`) +- [**lighting**](./lighting/): Reinforcement learning for agents (`agent-framework-lab-lighting`) + +## How do I contribute? + +This repo only contains lab packages maintained by Microsoft. +If you want to contribute, please take the following steps: + +1. Follow the [Create a New Lab Package](#create-new-lab-package) guide + below to create your own lab package. +2. Create a new repo on GitHub and check in your package there. +3. Tag your repo with `agent-framework-lab` for bettter discovery. +4. Submit a PR to this repo (github.com/microsoft/agent-framework) + to add a link to your repo in the [list](#lab-packages) above. + **The PR title must contain "[New Lab Package]"**. +5. We will review your repo and decide whether to approve it. + +Follow the [guidelines](#guidelines) when you create your package, our decision +to accept your PR will be based on your idea as well as the quality of your +code. + +We may decide to maintain your package in this repo. In that case, we will +contact you directly. + +## Package Structure + +Each lab package follows this structure: + +``` +packages/lab/{lab_name}/ +├── agent_framework/ +│ └── lab/ +│ └── {lab_name}/ +│ └── __init__.py # Imports from agent_framework_lab_{lab_name} +├── agent_framework_lab_{lab_name}/ # Actual implementation package +│ ├── __init__.py # Main exports and __version__ +│ ├── {module_files}.py # Implementation modules +│ └── py.typed # Type hints marker +├── tests/ +│ ├── __init__.py +│ └── test_{lab_name}.py # Package tests +├── pyproject.toml # Package configuration +├── README.md # Package-specific documentation +└── LICENSE # MIT License +``` + +## Creating a New Lab Package + +### Create The Package + +First ensure `cookiecutter` is installed. + +```bash +pip install cookiecutter +``` + +Then go to the directory where you want to create the package: + +```bash +cookiecutter /path/to/agent-framework/python/packages/lab/cookiecutter-agent-framework-lab +``` + +You will be prompted for: + +- **package_name**: The name of your lab package (e.g., "lighting", "vision") +- **package_display_name**: Human-readable name (e.g., "Lighting Tools", "Computer Vision") +- **package_description**: Brief description (auto-generated from display name) +- **include_cli_script**: Whether to include a CLI script (y/n) + +### After Package Creation + +1. **Implement your functionality** in `agent_framework_lab_your_package_name/` +2. **Update exports** in `__init__.py` `__all__` list +3. **Add dependencies** to `pyproject.toml` +4. **Write tests** in the `tests/` directory +5. **Update README** with usage examples and API documentation + +### Add to Workspace (only for packages maintained in this repo) + +After creating your package, add it to the workspace configuration: + +``` +# Edit python/pyproject.toml +# Add to dependencies section: +dependencies = [ + # ... existing packages ... + "agent-framework-lab-your-package-name", +] + +# Add to [tool.uv.sources] section: +agent-framework-lab-your-package-name = { workspace = true } +``` + +### Usage + +Once created, users can install your lab package + +1. directly from your repo: + +```bash +pip install git+https://github.com/your-username/your-lab-package-repo.git +``` + +2. or from PyPI if you have uploaded your lab package there: + +```bash +pip install "agent-framework-lab-your-package-name" +``` + +Then, they can use your lab package: + +```python +from agent_framework.lab.your_package_name import YourClass, your_function + +# Use the functionality +instance = YourClass() +result = your_function() +``` + +## Guidelines + +1. **Naming**: Use lowercase with hyphens for package names (`agent-framework-lab-your-package-name`) +2. **Namespace**: Always use `agent_framework.lab.your_package_name` for imports +3. **Versioning**: Start with `0.1.0b1` for beta releases +4. **Dependencies**: Minimize external dependencies, always include `agent-framework` +5. **Documentation**: Include comprehensive README with usage examples +6. **Tests**: Write comprehensive tests with good coverage +7. **Type hints**: Always include type hints and `py.typed` file diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/README.md b/python/packages/lab/cookiecutter-agent-framework-lab/README.md new file mode 100644 index 0000000000..b7eda61fa8 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/README.md @@ -0,0 +1,58 @@ +# Cookiecutter Template for Agent Framework Lab Packages + +This is a cookiecutter template for creating new lab packages in the Microsoft Agent Framework. + +## Usage + +```bash +cd /path/to/agent-framework/python/packages/lab +cookiecutter ./cookiecutter-agent-framework-lab +``` + +You will be prompted for the following information: + +- **package_name**: The name of your lab package (e.g., "lighting", "vision") +- **package_display_name**: Human-readable name (e.g., "Lighting Tools", "Computer Vision") +- **package_description**: Brief description of the package (auto-generated from display name) +- **version**: Starting version (default: 0.1.0b1) +- **author_name**: Author name (default: Microsoft) +- **author_email**: Author email (default: SK-Support@microsoft.com) +- **include_cli_script**: Whether to include a CLI script (y/n) +- **cli_script_name**: Name of CLI script if included + +## What Gets Generated + +The template creates a complete lab package structure: + +``` +{package_name}/ +├── agent_framework/ +│ └── lab/ +│ └── {package_name}/ +│ └── __init__.py +├── agent_framework_lab_{package_name}/ +│ ├── __init__.py +│ └── py.typed +├── tests/ +│ ├── __init__.py +│ └── test_{package_name}.py +├── pyproject.toml +├── README.md +└── LICENSE +``` + +## After Generation + +1. Implement your functionality in `agent_framework_lab_{package_name}/` +2. Update the `__all__` exports in `__init__.py` +3. Add your dependencies to `pyproject.toml` +4. Write comprehensive tests +5. Update the README with usage examples + +## Integration + +Don't forget to add your new package to the workspace: + +1. Add to `python/pyproject.toml` dependencies +2. Add to `[tool.uv.sources]` section +3. Test installation with `uv run python -c "from agent_framework.lab.{name} import *"` \ No newline at end of file diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/cookiecutter.json b/python/packages/lab/cookiecutter-agent-framework-lab/cookiecutter.json new file mode 100644 index 0000000000..69098cc01f --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/cookiecutter.json @@ -0,0 +1,20 @@ +{ + "package_name": "", + "package_display_name": "", + "package_description": "{{ cookiecutter.package_display_name }} module for Microsoft Agent Framework.", + "version": "0.1.0b1", + "author_name": "Microsoft", + "author_email": "SK-Support@microsoft.com", + "license": "MIT", + "include_cli_script": ["y", "n"], + "cli_script_name": "{{ cookiecutter.package_name }}_cli", + "python_requires": ">=3.10", + "within_microsoft_agent_framework_repo": ["y", "n"], + "__prompts__": { + "within_microsoft_agent_framework_repo": "Are you creating this package within the github.com/microsoft/agent-framework repo or a fork of it? (If yes, ensure you create it in python/packages/lab/ directory)" + }, + "_templates_suffix": "", + "_copy_without_render": [ + "*.py.typed" + ] +} \ No newline at end of file diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/LICENSE b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/LICENSE new file mode 100644 index 0000000000..22aed37e65 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Microsoft Corporation. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/README.md b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/README.md new file mode 100644 index 0000000000..586b2db371 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/README.md @@ -0,0 +1,56 @@ +# Agent Framework Lab - {{ cookiecutter.package_display_name }} + +{{ cookiecutter.package_description }} + +## Installation + +```bash +pip install agent-framework-lab-{{ cookiecutter.package_name }} +``` + +## Usage + +```python +from agent_framework.lab.{{ cookiecutter.package_name }} import YourClass + +# Your usage example here +instance = YourClass() +``` + +## Overview + +Brief description of what this lab package provides and its main features. + +## Features + +- Feature 1: Description +- Feature 2: Description +- Feature 3: Description + +## Examples + +### Basic Usage + +```python +from agent_framework.lab.{{ cookiecutter.package_name }} import YourClass + +# Example usage +``` + +### Advanced Usage + +```python +# More advanced examples +``` + +## API Reference + +Document your main classes and functions here. + +## Contributing + +This package is part of the Microsoft Agent Framework Lab. Please see the main repository for contribution guidelines. + +## License + +This project is licensed under the {{ cookiecutter.license }} License - see the LICENSE file for details. \ No newline at end of file diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/__init__.py b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/__init__.py new file mode 100644 index 0000000000..1d3db512a4 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/lab/__init__.py b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/lab/__init__.py new file mode 100644 index 0000000000..0d8d8fbaa4 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/lab/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework.lab a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/lab/{{cookiecutter.package_name}}/__init__.py b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/lab/{{cookiecutter.package_name}}/__init__.py new file mode 100644 index 0000000000..24ee74ae3e --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework/lab/{{cookiecutter.package_name}}/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# Import and re-export from the actual implementation +from agent_framework_lab_{{cookiecutter.package_name}} import * # noqa: F403, F401 diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework_lab_{{cookiecutter.package_name}}/__init__.py b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework_lab_{{cookiecutter.package_name}}/__init__.py new file mode 100644 index 0000000000..d2d082187c --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework_lab_{{cookiecutter.package_name}}/__init__.py @@ -0,0 +1,16 @@ +# Copyright (c) Microsoft. All rights reserved. + +""" +{{ cookiecutter.package_description }} +""" + +# Import your main exports here +# from .main_module import MainClass, main_function + +__all__ = [ + # List your exports here + # "MainClass", + # "main_function", +] + +__version__ = "{{ cookiecutter.version }}" diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework_lab_{{cookiecutter.package_name}}/py.typed b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/agent_framework_lab_{{cookiecutter.package_name}}/py.typed new file mode 100644 index 0000000000..e69de29bb2 diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/pyproject.toml b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/pyproject.toml new file mode 100644 index 0000000000..f9b0b66149 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/pyproject.toml @@ -0,0 +1,94 @@ +[project] +name = "agent-framework-lab-{{ cookiecutter.package_name }}" +description = "{{ cookiecutter.package_description }}" +authors = [{ name = "{{ cookiecutter.author_name }}", email = "{{ cookiecutter.author_email }}"}] +readme = "README.md" +requires-python = "{{ cookiecutter.python_requires }}" +version = "{{ cookiecutter.version }}" +license-files = ["LICENSE"] +urls.homepage = "https://learn.microsoft.com/en-us/semantic-kernel/overview/" +urls.source = "https://github.com/microsoft/agent-framework/tree/main/python" +urls.release_notes = "https://github.com/microsoft/agent-framework/releases?q=tag%3Apython-1&expanded=true" +urls.issues = "https://github.com/microsoft/agent-framework/issues" +classifiers = [ + "License :: OSI Approved :: {{ cookiecutter.license }} License", + "Development Status :: 2 - Pre-Alpha", + "Intended Audience :: Developers", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", +] +dependencies = [ + "agent-framework", + "pydantic>=2.0.0", + # Add your specific dependencies here +] + +{% if cookiecutter.include_cli_script == "y" %} +[project.scripts] +{{ cookiecutter.cli_script_name }} = "agent_framework_lab_{{ cookiecutter.package_name }}:main" +{% endif %} + +[build-system] +requires = ["setuptools>=64", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.setuptools] +packages = ["agent_framework_lab_{{ cookiecutter.package_name }}", "agent_framework.lab.{{ cookiecutter.package_name }}"] + +[tool.setuptools.package-data] +agent_framework_lab_{{ cookiecutter.package_name }} = ["py.typed"] + +[tool.ruff] +line-length = 120 +target-version = "py310" +extend-exclude = ["tests", "__pycache__"] + +[tool.ruff.lint] +select = ["E", "F", "I", "W", "UP", "C4", "N"] +ignore = ["N803", "N806", "N999", "UP007"] + +[tool.ruff.format] +quote-style = "double" + +[tool.mypy] +python_version = "3.10" +strict = true +check_untyped_defs = true +disallow_untyped_defs = true +disallow_incomplete_defs = true +disallow_untyped_decorators = true +warn_redundant_casts = true +warn_unused_ignores = true +warn_return_any = true +warn_unreachable = true +show_error_codes = true +implicit_reexport = true +packages = ["agent_framework_lab_{{ cookiecutter.package_name }}"] + +{% if cookiecutter.within_microsoft_agent_framework_repo == "y" %} +[tool.poe] +executor.type = "uv" +include = "../../../shared_tasks.toml" +[tool.poe.tasks] +test = "pytest --cov=agent_framework_lab_{{ cookiecutter.package_name }} --cov-report=term-missing:skip-covered tests" +mypy = "mypy agent_framework_lab_{{ cookiecutter.package_name }}" +{% else %} +[tool.poe.tasks] +fmt = "ruff format" +format = "ruff format" +lint = "ruff check" +test = "pytest --cov=agent_framework_lab_{{ cookiecutter.package_name }} --cov-report=term-missing:skip-covered tests" +mypy = "mypy agent_framework_lab_{{ cookiecutter.package_name }}" +{% endif %} + +[tool.pytest.ini_options] +testpaths = ["tests"] +pythonpath = ["."] +addopts = "--strict-markers --strict-config" +markers = [ + "unit: marks tests as unit tests", + "integration: marks tests as integration tests", +] \ No newline at end of file diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/tests/__init__.py b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/tests/__init__.py new file mode 100644 index 0000000000..2a50eae894 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/tests/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Microsoft. All rights reserved. diff --git a/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/tests/test_{{cookiecutter.package_name}}.py b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/tests/test_{{cookiecutter.package_name}}.py new file mode 100644 index 0000000000..f832f0ab37 --- /dev/null +++ b/python/packages/lab/cookiecutter-agent-framework-lab/{{cookiecutter.package_name}}/tests/test_{{cookiecutter.package_name}}.py @@ -0,0 +1,15 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Tests for {{ cookiecutter.package_name }} module.""" + +import pytest +from agent_framework_lab_{{cookiecutter.package_name}} import __version__ + + +class Test{{cookiecutter.package_name | title}}: + """Test the {{ cookiecutter.package_name }} module.""" + + def test_version(self): + """Test package version is defined.""" + assert __version__ is not None + assert __version__ == "{{ cookiecutter.version }}" diff --git a/python/packages/lab/gaia/LICENSE b/python/packages/lab/gaia/LICENSE new file mode 100644 index 0000000000..22aed37e65 --- /dev/null +++ b/python/packages/lab/gaia/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Microsoft Corporation. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/python/packages/lab/gaia/README.md b/python/packages/lab/gaia/README.md new file mode 100644 index 0000000000..235e1e4e54 --- /dev/null +++ b/python/packages/lab/gaia/README.md @@ -0,0 +1,65 @@ +# Agent Framework Lab - GAIA + +The GAIA benchmark can be used for evaluating agents and workflows built using the Agent Framework. +It includes built-in benchmarks as well as utilities for running custom evaluations. + +## Setup + +Use `uv` to install the package with GAIA dependencies: + +```bash +uv pip install "agent-framework-lab-gaia" +``` + +Set up Hugging Face token: + +```bash +export HF_TOKEN="hf\*..." # must have access to gaia-benchmark/GAIA +``` + +## Create an evaluation script + +Create a Python script (e.g., `run_gaia.py`) with the following content: + +```python +from agent_framework.lab.gaia import GAIA, Task, Prediction, GAIATelemetryConfig + +async def run_task(task: Task) -> Prediction: + return Prediction(prediction="answer here", messages=[]) + +async def main() -> None: + # Optional: Enable telemetry for detailed tracing + telemetry_config = GAIATelemetryConfig( + enable_tracing=True, + trace_to_file=True, + file_path="gaia_traces.jsonl" + ) + + runner = GAIA(telemetry_config=telemetry_config) + await runner.run(run_task, level=1, max_n=5, parallel=2) +``` + +See the [gaia_sample.py](./samples/gaia_sample.py) for more detail. + +### Run the evaluation + +Run the evaluation script using `uv`: + +```bash +uv run python run_gaia.py +``` + +By default, the script will first look for cached GAIA data in the `data_gaia_hub` directory, +and download it if not found. +The result will be saved to `gaia_results_.jsonl`. + +**Don't run the script inside this directory because it will confuse the local `agent_framework` namespace +package with the real one.** + +## View results + +We provide a console viewer for reading GAIA results: + +```bash +uv run gaia_viewer "gaia_results_.jsonl" --detailed +``` diff --git a/python/packages/lab/gaia/agent_framework/__init__.py b/python/packages/lab/gaia/agent_framework/__init__.py new file mode 100644 index 0000000000..1d3db512a4 --- /dev/null +++ b/python/packages/lab/gaia/agent_framework/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/packages/lab/gaia/agent_framework/lab/__init__.py b/python/packages/lab/gaia/agent_framework/lab/__init__.py new file mode 100644 index 0000000000..0d8d8fbaa4 --- /dev/null +++ b/python/packages/lab/gaia/agent_framework/lab/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework.lab a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/packages/lab/gaia/agent_framework/lab/gaia/__init__.py b/python/packages/lab/gaia/agent_framework/lab/gaia/__init__.py new file mode 100644 index 0000000000..cc4cc7e9a6 --- /dev/null +++ b/python/packages/lab/gaia/agent_framework/lab/gaia/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# Import and re-export from the actual implementation +from agent_framework_lab_gaia import * # noqa: F403, F401 diff --git a/python/packages/lab/gaia/agent_framework_lab_gaia/__init__.py b/python/packages/lab/gaia/agent_framework_lab_gaia/__init__.py new file mode 100644 index 0000000000..d746acb4bb --- /dev/null +++ b/python/packages/lab/gaia/agent_framework_lab_gaia/__init__.py @@ -0,0 +1,23 @@ +# Copyright (c) Microsoft. All rights reserved. + +""" +GAIA benchmark module for Agent Framework. +""" + +from ._types import Evaluation, Evaluator, Prediction, Task, TaskResult, TaskRunner +from .gaia import GAIA, GAIATelemetryConfig, gaia_scorer, viewer_main + +__all__ = [ + "GAIA", + "GAIATelemetryConfig", + "gaia_scorer", + "viewer_main", + "Task", + "Prediction", + "Evaluation", + "TaskResult", + "TaskRunner", + "Evaluator", +] + +__version__ = "0.1.0b1" diff --git a/python/packages/lab/gaia/agent_framework_lab_gaia/_types.py b/python/packages/lab/gaia/agent_framework_lab_gaia/_types.py new file mode 100644 index 0000000000..d06ded1906 --- /dev/null +++ b/python/packages/lab/gaia/agent_framework_lab_gaia/_types.py @@ -0,0 +1,79 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Common types for agent evaluation.""" + +from dataclasses import dataclass +from typing import Any, Protocol, runtime_checkable + +__all__ = [ + "Task", + "Prediction", + "Evaluation", + "TaskResult", + "TaskRunner", + "Evaluator", +] + + +@dataclass +class Task: + """Represents a task to be evaluated.""" + + task_id: str + question: str + answer: str | None = None + level: int | None = None + file_name: str | None = None + metadata: dict[str, Any] | None = None + + +@dataclass +class Prediction: + """Represents a prediction made by an agent for a task.""" + + prediction: str + messages: list[Any] | None = None + metadata: dict[str, Any] | None = None + + def __post_init__(self) -> None: + if self.messages is None: + self.messages = [] + + +@dataclass +class Evaluation: + """Represents the evaluation result of a prediction.""" + + is_correct: bool + score: float + details: dict[str, Any] | None = None + + +@dataclass +class TaskResult: + """Complete result for a single task evaluation.""" + + task_id: str + task: Task + prediction: Prediction + evaluation: Evaluation + runtime_seconds: float | None = None + error: str | None = None + + +@runtime_checkable +class TaskRunner(Protocol): + """Protocol for running tasks.""" + + async def __call__(self, task: Task) -> Prediction: + """Run a single task and return the prediction.""" + ... + + +@runtime_checkable +class Evaluator(Protocol): + """Protocol for evaluating predictions.""" + + async def __call__(self, task: Task, prediction: Prediction) -> Evaluation: + """Evaluate a prediction for a given task.""" + ... diff --git a/python/packages/lab/gaia/agent_framework_lab_gaia/gaia.py b/python/packages/lab/gaia/agent_framework_lab_gaia/gaia.py new file mode 100644 index 0000000000..5a345137c4 --- /dev/null +++ b/python/packages/lab/gaia/agent_framework_lab_gaia/gaia.py @@ -0,0 +1,625 @@ +# Copyright (c) Microsoft. All rights reserved. + +""" +GAIA benchmark implementation for Agent Framework. +""" + +import asyncio +import json +import os +import random +import re +import string +import tempfile +import time +from collections.abc import Iterable +from datetime import datetime +from pathlib import Path +from typing import Any + +from opentelemetry.trace import NoOpTracer, SpanKind, get_tracer +from tqdm import tqdm + +from ._types import Evaluation, Evaluator, Prediction, Task, TaskResult, TaskRunner + +__all__ = ["GAIA", "gaia_scorer", "GAIATelemetryConfig"] + + +class GAIATelemetryConfig: + """Configuration for GAIA telemetry and tracing.""" + + def __init__( + self, + enable_tracing: bool = False, + otlp_endpoint: str | None = None, + application_insights_connection_string: str | None = None, + enable_live_metrics: bool = False, + trace_to_file: bool = False, + file_path: str | None = None, + ): + """ + Initialize telemetry configuration. + + Args: + enable_tracing: Whether to enable OpenTelemetry tracing + otlp_endpoint: OTLP endpoint for trace export + application_insights_connection_string: Azure Monitor connection string + enable_live_metrics: Enable Azure Monitor live metrics + trace_to_file: Whether to export traces to local file + file_path: Path for local file export (defaults to gaia_traces.json) + """ + self.enable_tracing = enable_tracing + self.otlp_endpoint = otlp_endpoint + self.application_insights_connection_string = application_insights_connection_string + self.enable_live_metrics = enable_live_metrics + self.trace_to_file = trace_to_file + self.file_path = file_path or "gaia_traces.json" + + def setup_telemetry(self) -> None: + """Set up OpenTelemetry based on configuration.""" + if not self.enable_tracing: + return + + from agent_framework.telemetry import setup_telemetry + + setup_telemetry( + enable_otel=True, + enable_sensitive_data=True, # Enable for detailed task traces + otlp_endpoint=self.otlp_endpoint, + application_insights_connection_string=self.application_insights_connection_string, + enable_live_metrics=self.enable_live_metrics, + ) + + # Set up local file export if requested + if self.trace_to_file: + self._setup_file_export() + + def _setup_file_export(self) -> None: + """Set up local file export for traces.""" + try: + import json + import os + + from opentelemetry.sdk.trace import TracerProvider + from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExporter, SpanExportResult + from opentelemetry.trace import get_tracer_provider + + class FileSpanExporter(SpanExporter): + def __init__(self, file_path: str): + self.file_path = file_path + # Ensure directory exists + os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True) + + def export(self, spans) -> SpanExportResult: + try: + with open(self.file_path, "a", encoding="utf-8") as f: + for span in spans: + span_data = { + "trace_id": format(span.context.trace_id, "032x") if span.context else "unknown", + "span_id": format(span.context.span_id, "016x") if span.context else "unknown", + "name": span.name, + "start_time": span.start_time, + "end_time": span.end_time, + "duration_ns": (span.end_time - span.start_time) + if (span.end_time and span.start_time) + else None, + "attributes": dict(span.attributes) if span.attributes else {}, + "status": { + "status_code": span.status.status_code.name if span.status else "UNSET", + "description": span.status.description if span.status else None, + }, + } + f.write(json.dumps(span_data, default=str) + "\n") + return SpanExportResult.SUCCESS + except Exception: + return SpanExportResult.FAILURE + + def shutdown(self) -> None: + pass + + tracer_provider = get_tracer_provider() + if isinstance(tracer_provider, TracerProvider): + file_exporter = FileSpanExporter(self.file_path) + tracer_provider.add_span_processor(BatchSpanProcessor(file_exporter)) + + except ImportError: + print("Warning: Could not set up file export for traces. Missing dependencies.") + + +def _normalize_number_str(number_str: str) -> float: + """Normalize a number string for comparison.""" + for ch in ["$", "%", ","]: + number_str = number_str.replace(ch, "") + try: + return float(number_str) + except ValueError: + return float("inf") + + +def _split_string(s: str, chars: list[str] = [",", ";"]) -> list[str]: + """Split string by multiple delimiters.""" + return re.split(f"[{''.join(chars)}]", s) + + +def _normalize_str(s: str, remove_punct: bool = True) -> str: + """Normalize string for comparison.""" + no_spaces = re.sub(r"\s", "", s or "") + if remove_punct: + table = str.maketrans("", "", string.punctuation) + return no_spaces.lower().translate(table) + return no_spaces.lower() + + +def gaia_scorer(model_answer: str, ground_truth: str) -> bool: + """ + Official GAIA scoring function. + + Args: + model_answer: The model's answer + ground_truth: The ground truth answer + + Returns: + True if the answer is correct, False otherwise + """ + + def is_float(x: Any) -> bool: + try: + float(x) + return True + except Exception: + return False + + if model_answer is None: + model_answer = "None" + + if is_float(ground_truth): + # numeric exact match after normalization + return _normalize_number_str(model_answer) == float(ground_truth) + elif any(ch in ground_truth for ch in [",", ";"]): + # list with per-element compare (number or string) + gt_elems = _split_string(ground_truth) + ma_elems = _split_string(model_answer) + if len(gt_elems) != len(ma_elems): + return False + comparisons = [] + for ma, gt in zip(ma_elems, gt_elems): + if is_float(gt): + comparisons.append(_normalize_number_str(ma) == float(gt)) + else: + comparisons.append(_normalize_str(ma, remove_punct=False) == _normalize_str(gt, remove_punct=False)) + return all(comparisons) + else: + # string normalize + exact + return _normalize_str(model_answer) == _normalize_str(ground_truth) + + +def _read_jsonl(path: Path) -> Iterable[dict[str, Any]]: + """Read JSONL file and yield parsed records.""" + with path.open("rb") as f: + for line in f: + if not line.strip(): + continue + try: + import orjson + + yield orjson.loads(line) + except Exception: + yield json.loads(line) + + +def _load_gaia_local(repo_dir: Path, wanted_levels: list[int] | None = None, max_n: int | None = None) -> list[Task]: + """Load GAIA tasks from local repository directory.""" + tasks: list[Task] = [] + + for p in repo_dir.rglob("metadata.jsonl"): + for rec in _read_jsonl(p): + # Robustly extract fields used across variants + q = rec.get("Question") or rec.get("question") or rec.get("query") or rec.get("prompt") + ans = rec.get("Final answer") or rec.get("answer") or rec.get("final_answer") + qid = str( + rec.get("task_id") + or rec.get("question_id") + or rec.get("id") + or rec.get("uuid") + or f"{p.stem}:{len(tasks)}" + ) + lvl = rec.get("Level") or rec.get("level") + fname = rec.get("file_name") or rec.get("filename") or None + + # Only evaluate examples with public answers (dev/validation split) + if not q or ans is None: + continue + + if wanted_levels and (lvl not in wanted_levels): + continue + + tasks.append(Task(task_id=qid, question=q, answer=str(ans), level=lvl, file_name=fname, metadata=rec)) + + # Shuffle to help with rate-limits and fairness if max_n is provided + random.shuffle(tasks) + if max_n: + tasks = tasks[:max_n] + return tasks + + +class GAIA: + """ + GAIA benchmark runner for Agent Framework. + + GAIA (General AI Assistant) is a benchmark for general-purpose AI assistants. + This class provides utilities to run the benchmark with custom agents. + """ + + def __init__( + self, + evaluator: Evaluator | None = None, + data_dir: str | None = None, + hf_token: str | None = None, + telemetry_config: GAIATelemetryConfig | None = None, + ): + """ + Initialize GAIA benchmark runner. + + Args: + evaluator: Custom evaluator function. If None, uses default GAIA scorer. + data_dir: Directory to cache GAIA data. Defaults to a temporary directory. + hf_token: Hugging Face token for accessing the GAIA dataset. + telemetry_config: Configuration for telemetry and tracing. If None, no tracing is performed. + """ + self.evaluator = evaluator or self._default_evaluator + self.data_dir = Path(data_dir or Path(tempfile.gettempdir()) / "data_gaia_hub") + self.hf_token = hf_token + self.telemetry_config = telemetry_config or GAIATelemetryConfig() + + # Set up telemetry + self.telemetry_config.setup_telemetry() + + # Initialize tracer + if self.telemetry_config.enable_tracing: + self.tracer = get_tracer("gaia_benchmark", "1.0.0") + else: + self.tracer = NoOpTracer() + + async def _default_evaluator(self, task: Task, prediction: Prediction) -> Evaluation: + """Default evaluator using GAIA official scoring.""" + is_correct = gaia_scorer(prediction.prediction, task.answer or "") + return Evaluation(is_correct=is_correct, score=1.0 if is_correct else 0.0) + + def _ensure_data(self) -> Path: + """Ensure GAIA data is available locally.""" + + if self.data_dir.exists() and any(self.data_dir.rglob("metadata.jsonl")): + return self.data_dir + + # Download data if not available + token = self.hf_token or os.environ.get("HF_TOKEN") + if not token: + raise RuntimeError( + "HF_TOKEN environment variable or hf_token parameter is required " + "to access the GAIA dataset. Please set your Hugging Face token " + "with access to gaia-benchmark/GAIA." + ) + + print(f"Downloading GAIA dataset to {self.data_dir}...") + from huggingface_hub import snapshot_download + + local_dir = snapshot_download( + repo_id="gaia-benchmark/GAIA", + repo_type="dataset", + token=token, + local_dir=str(self.data_dir), + local_dir_use_symlinks=False, + force_download=False, + ) + return Path(local_dir) + + async def _run_single_task( + self, task: Task, task_runner: TaskRunner, semaphore: asyncio.Semaphore, timeout: int | None = None + ) -> TaskResult: + """Run a single task with error handling and timing.""" + async with semaphore: + with self.tracer.start_as_current_span( + "gaia.task.run", + kind=SpanKind.INTERNAL, + attributes={ + "gaia.task.id": task.task_id, + "gaia.task.level": task.level or 0, + "gaia.task.has_file": task.file_name is not None, + "gaia.task.timeout": timeout or 0, + }, + ) as span: + start_time = time.time() + try: + # Add task execution span + with self.tracer.start_as_current_span( + "gaia.task.execute", + kind=SpanKind.INTERNAL, + attributes={ + "gaia.task.question_length": len(task.question or ""), + "gaia.task.file_name": task.file_name or "", + }, + ): + if timeout: + prediction = await asyncio.wait_for(task_runner(task), timeout=timeout) + else: + prediction = await task_runner(task) + + # Add evaluation span + with self.tracer.start_as_current_span("gaia.task.evaluate", kind=SpanKind.INTERNAL): + evaluation = await self.evaluator(task, prediction) + + runtime_seconds = time.time() - start_time + + # Add results to span + if span: + span.set_attributes( + { + "gaia.task.runtime_seconds": runtime_seconds, + "gaia.task.is_correct": evaluation.is_correct, + "gaia.task.score": evaluation.score, + "gaia.task.prediction_length": len(prediction.prediction or ""), + } + ) + + return TaskResult( + task_id=task.task_id, + task=task, + prediction=prediction, + evaluation=evaluation, + runtime_seconds=runtime_seconds, + ) + except Exception as e: + runtime_seconds = time.time() - start_time + + # Record error in span + if span: + span.set_attributes( + { + "gaia.task.runtime_seconds": runtime_seconds, + "gaia.task.error": str(e), + "gaia.task.is_correct": False, + "gaia.task.score": 0.0, + } + ) + span.record_exception(e) + + return TaskResult( + task_id=task.task_id, + task=task, + prediction=Prediction(prediction="", messages=[]), + evaluation=Evaluation(is_correct=False, score=0.0), + runtime_seconds=runtime_seconds, + error=str(e), + ) + + async def run( + self, + task_runner: TaskRunner, + level: int | list[int] = 1, + max_n: int | None = None, + parallel: int = 1, + timeout: int | None = None, + out: str | None = None, + ) -> list[TaskResult]: + """ + Run the GAIA benchmark. + + Args: + task_runner: Function that takes a Task and returns a Prediction + level: GAIA level(s) to run (1, 2, 3, or list of levels) + max_n: Maximum number of tasks to run per level + parallel: Number of parallel tasks to run + timeout: Timeout per task in seconds + out: Output file to save results including detailed traces (optional) + + Returns: + List of TaskResult objects + """ + with self.tracer.start_as_current_span( + "gaia.benchmark.run", + kind=SpanKind.INTERNAL, + attributes={ + "gaia.benchmark.levels": str(level), + "gaia.benchmark.max_n": max_n or 0, + "gaia.benchmark.parallel": parallel, + "gaia.benchmark.timeout": timeout or 0, + }, + ) as benchmark_span: + # Ensure data is available + with self.tracer.start_as_current_span("gaia.data.ensure", kind=SpanKind.INTERNAL): + data_path = self._ensure_data() + + # Parse level parameter + if isinstance(level, int): + levels = [level] + else: + levels = level + + # Load tasks + with self.tracer.start_as_current_span( + "gaia.tasks.load", + kind=SpanKind.INTERNAL, + attributes={ + "gaia.tasks.levels": str(levels), + "gaia.tasks.max_n": max_n or 0, + }, + ) as load_span: + tasks = _load_gaia_local(data_path, wanted_levels=levels, max_n=max_n) + + if load_span: + load_span.set_attributes( + { + "gaia.tasks.loaded_count": len(tasks), + } + ) + + if not tasks: + raise RuntimeError( + f"No GAIA tasks found for levels {levels}. " + "Make sure you have dataset access and selected valid levels." + ) + + print(f"Running {len(tasks)} GAIA tasks (levels={levels}) with {parallel} parallel workers...") + + # Update benchmark span with task info + if benchmark_span: + benchmark_span.set_attributes( + { + "gaia.benchmark.total_tasks": len(tasks), + } + ) + + # Run tasks + semaphore = asyncio.Semaphore(parallel) + results = [] + + tasks_coroutines = [self._run_single_task(task, task_runner, semaphore, timeout) for task in tasks] + + with self.tracer.start_as_current_span("gaia.tasks.execute_all", kind=SpanKind.INTERNAL): + for coro in tqdm( + asyncio.as_completed(tasks_coroutines), total=len(tasks_coroutines), desc="Evaluating tasks" + ): + result = await coro + results.append(result) + + # Calculate summary statistics + correct = sum(1 for r in results if r.evaluation.is_correct) + accuracy = correct / len(results) if results else 0.0 + avg_runtime = sum(r.runtime_seconds or 0 for r in results) / len(results) if results else 0.0 + + # Update benchmark span with final results + if benchmark_span: + benchmark_span.set_attributes( + { + "gaia.benchmark.accuracy": accuracy, + "gaia.benchmark.correct_count": correct, + "gaia.benchmark.total_count": len(results), + "gaia.benchmark.avg_runtime_seconds": avg_runtime, + } + ) + + print("\nGAIA Benchmark Results:") + print(f"Accuracy: {accuracy:.3f} ({correct}/{len(results)})") + print(f"Average runtime: {avg_runtime:.2f}s") + + # Save results if requested + if out: + with self.tracer.start_as_current_span( + "gaia.results.save", kind=SpanKind.INTERNAL, attributes={"gaia.results.output_file": out} + ): + self._save_results(results, out) + print(f"Results saved to {out}") + + return results + + def _save_results(self, results: list[TaskResult], output_path: str) -> None: + """Save results with detailed trace information to JSONL file.""" + with open(output_path, "w", encoding="utf-8") as f: + for result in results: + # Convert messages to serializable format + serializable_messages = [] + if result.prediction.messages: + for msg in result.prediction.messages: + if hasattr(msg, "model_dump"): + # Pydantic model + serializable_messages.append(msg.model_dump()) + elif hasattr(msg, "__dict__"): + # Regular object with attributes + serializable_messages.append(vars(msg)) + else: + # Fallback to string representation + serializable_messages.append(str(msg)) + + record = { + "task_id": result.task_id, + "level": result.task.level, + "question": result.task.question, + "answer": result.task.answer, + "prediction": result.prediction.prediction, + "is_correct": result.evaluation.is_correct, + "score": result.evaluation.score, + "runtime_seconds": result.runtime_seconds, + "error": result.error, + "timestamp": datetime.now().isoformat(), + # Include detailed trace information + "task_metadata": result.task.metadata, + "file_name": result.task.file_name, + "messages": serializable_messages, + "prediction_metadata": result.prediction.metadata, + "evaluation_details": result.evaluation.details, + } + try: + import orjson + + f.write(orjson.dumps(record, default=str).decode("utf-8") + "\n") + except ImportError: + f.write(json.dumps(record, default=str) + "\n") + + +def viewer_main() -> None: + """Main function for the gaia_viewer script.""" + import argparse + + parser = argparse.ArgumentParser(description="View GAIA benchmark results") + parser.add_argument("results_file", help="Path to results JSONL file") + parser.add_argument("--detailed", action="store_true", help="Show detailed view") + parser.add_argument("--level", type=int, help="Filter by level") + parser.add_argument("--correct-only", action="store_true", help="Show only correct answers") + parser.add_argument("--incorrect-only", action="store_true", help="Show only incorrect answers") + + args = parser.parse_args() + + # Load results + results = [] + with open(args.results_file, encoding="utf-8") as f: + for line in f: + if line.strip(): + try: + import orjson + + results.append(orjson.loads(line)) + except ImportError: + results.append(json.loads(line)) + + # Apply filters + if args.level is not None: + results = [r for r in results if r.get("level") == args.level] + + if args.correct_only: + results = [r for r in results if r.get("is_correct")] + elif args.incorrect_only: + results = [r for r in results if not r.get("is_correct")] + + # Display results + if not results: + print("No results match the filters.") + return + + total = len(results) + correct = sum(1 for r in results if r.get("is_correct")) + accuracy = correct / total if total > 0 else 0.0 + + print("GAIA Results Summary:") + print(f"Total: {total}, Correct: {correct}, Accuracy: {accuracy:.3f}") + print("-" * 80) + + for i, result in enumerate(results, 1): + status = "✓" if result.get("is_correct") else "✗" + level = result.get("level", "?") + task_id = result.get("task_id", "unknown") + + print(f"[{i}/{total}] {status} Level {level} - {task_id}") + + if args.detailed: + print(f"Question: {result.get('question', 'N/A')[:100]}...") + print(f"Answer: {result.get('answer', 'N/A')}") + print(f"Prediction: {result.get('prediction', 'N/A')}") + if result.get("error"): + print(f"Error: {result.get('error')}") + if result.get("runtime_seconds"): + print(f"Runtime: {result.get('runtime_seconds'):.2f}s") + print("-" * 40) + + +if __name__ == "__main__": + viewer_main() diff --git a/python/packages/lab/gaia/agent_framework_lab_gaia/py.typed b/python/packages/lab/gaia/agent_framework_lab_gaia/py.typed new file mode 100644 index 0000000000..c33f70a926 --- /dev/null +++ b/python/packages/lab/gaia/agent_framework_lab_gaia/py.typed @@ -0,0 +1 @@ +py.typed diff --git a/python/packages/lab/gaia/pyproject.toml b/python/packages/lab/gaia/pyproject.toml new file mode 100644 index 0000000000..6896c2c8a4 --- /dev/null +++ b/python/packages/lab/gaia/pyproject.toml @@ -0,0 +1,84 @@ +[project] +name = "agent-framework-lab-gaia" +description = "GAIA benchmark module for Microsoft Agent Framework." +authors = [{ name = "Microsoft", email = "SK-Support@microsoft.com"}] +readme = "README.md" +requires-python = ">=3.10" +version = "0.1.0b1" +license-files = ["LICENSE"] +urls.homepage = "https://learn.microsoft.com/en-us/semantic-kernel/overview/" +urls.source = "https://github.com/microsoft/agent-framework/tree/main/python" +urls.release_notes = "https://github.com/microsoft/agent-framework/releases?q=tag%3Apython-1&expanded=true" +urls.issues = "https://github.com/microsoft/agent-framework/issues" +classifiers = [ + "License :: OSI Approved :: MIT License", + "Development Status :: 2 - Pre-Alpha", + "Intended Audience :: Developers", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", +] +dependencies = [ + "agent-framework", + "pydantic>=2.0.0", + "opentelemetry-api>=1.24.0", + "tqdm>=4.60.0", + "huggingface-hub>=0.20.0", + "orjson>=3.8.0", +] + +[project.scripts] +gaia_viewer = "agent_framework_lab_gaia:viewer_main" + +[build-system] +requires = ["setuptools>=64", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.setuptools] +packages = ["agent_framework_lab_gaia", "agent_framework.lab.gaia"] + +[tool.setuptools.package-data] +agent_framework_lab_gaia = ["py.typed"] + +[tool.ruff] +line-length = 120 +target-version = "py310" +extend-exclude = ["tests", "__pycache__"] + +[tool.ruff.lint] +select = ["E", "F", "I", "W", "UP", "C4", "N"] +ignore = ["N803", "N806", "N999", "UP007"] + +[tool.ruff.format] +quote-style = "double" + +[tool.mypy] +python_version = "3.10" +strict = true +check_untyped_defs = true +disallow_untyped_defs = true +disallow_incomplete_defs = true +disallow_untyped_decorators = true +warn_redundant_casts = true +warn_unused_ignores = true +warn_return_any = true +warn_unreachable = true +show_error_codes = true +implicit_reexport = true +packages = ["agent_framework_lab_gaia"] + +[tool.poe] +executor.type = "uv" +include = "../../../shared_tasks.toml" +[tool.poe.tasks] + +[tool.pytest.ini_options] +testpaths = ["tests"] +pythonpath = ["."] +addopts = "--strict-markers --strict-config" +markers = [ + "unit: marks tests as unit tests", + "integration: marks tests as integration tests", +] \ No newline at end of file diff --git a/python/packages/lab/gaia/samples/gaia_sample.py b/python/packages/lab/gaia/samples/gaia_sample.py new file mode 100644 index 0000000000..81a848d9de --- /dev/null +++ b/python/packages/lab/gaia/samples/gaia_sample.py @@ -0,0 +1,83 @@ +# Copyright (c) Microsoft. All rights reserved. + +""" +GAIA Benchmark Sample + +To run this sample, execute it from the root directory of the agent-framework repository: + cd /path/to/agent-framework + uv run python python/packages/lab/gaia/gaia_sample.py + +This avoids namespace package conflicts that occur when running from within the gaia package directory. +""" + +from agent_framework.foundry import FoundryChatClient +from azure.identity.aio import AzureCliCredential + +from agent_framework.lab.gaia import GAIA, Evaluation, GAIATelemetryConfig, Prediction, Task + + +async def evaluate_task(task: Task, prediction: Prediction) -> Evaluation: + """Evaluate the prediction for a given task.""" + # Simple evaluation: check if the prediction contains the answer + is_correct = (task.answer or "").lower() in prediction.prediction.lower() + return Evaluation(is_correct=is_correct, score=1 if is_correct else 0) + + +async def main() -> None: + # Configure telemetry for tracing + telemetry_config = GAIATelemetryConfig( + enable_tracing=True, # Enable OpenTelemetry tracing + # Optional: Configure external endpoints + # otlp_endpoint="http://localhost:4317", # For Aspire Dashboard or other OTLP endpoints + # application_insights_connection_string="your_connection_string", # For Azure Monitor + # enable_live_metrics=True, # Enable Azure Monitor live metrics + # Configure local file tracing + trace_to_file=True, # Export traces to local file + file_path="gaia_benchmark_traces.jsonl", # Custom file path for traces + ) + + # Create a single agent once and reuse it for all tasks + async with ( + AzureCliCredential() as credential, + FoundryChatClient(async_credential=credential).create_agent( + name="GaiaAgent", + instructions="Solve tasks to your best ability.", + ) as agent, + ): + + async def run_task(task: Task) -> Prediction: + """Run a single GAIA task and return the prediction using the shared agent.""" + input_message = f"Task: {task.question}" + if task.file_name: + input_message += f"\nFile: {task.file_name}" + result = await agent.run(input_message) + return Prediction(prediction=result.text, messages=result.messages) + + # Create the GAIA benchmark runner with telemetry configuration + runner = GAIA(evaluator=evaluate_task, telemetry_config=telemetry_config) + + # Run the benchmark with the task runner. + # By default, this will check for locally cached benchmark data and checkout + # the latest version from HuggingFace if not found. + results = await runner.run( + run_task, + level=1, # Level 1, 2, or 3 or multiple levels like [1, 2] + max_n=5, # Maximum number of tasks to run per level + parallel=2, # Number of parallel tasks to run + timeout=60, # Timeout per task in seconds + out="gaia_results_level1.jsonl", # Output file to save results including detailed traces (optional) + ) + + # Print the results. + print("\n=== GAIA Benchmark Results ===") + for result in results: + print(f"\n--- Task ID: {result.task_id} ---") + print(f"Task: {result.task.question[:100]}...") + print(f"Prediction: {result.prediction.prediction}") + print(f"Evaluation: Correct={result.evaluation.is_correct}, Score={result.evaluation.score}") + + +if __name__ == "__main__": + import asyncio + + asyncio.run(main()) diff --git a/python/packages/lab/gaia/tests/__init__.py b/python/packages/lab/gaia/tests/__init__.py new file mode 100644 index 0000000000..2a50eae894 --- /dev/null +++ b/python/packages/lab/gaia/tests/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Microsoft. All rights reserved. diff --git a/python/packages/lab/gaia/tests/test_gaia.py b/python/packages/lab/gaia/tests/test_gaia.py new file mode 100644 index 0000000000..40d6791846 --- /dev/null +++ b/python/packages/lab/gaia/tests/test_gaia.py @@ -0,0 +1,37 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Tests for GAIA benchmark implementation.""" + +import pytest +from agent_framework_lab_gaia import gaia_scorer + + +class TestGAIAScorer: + """Test the GAIA scoring function.""" + + def test_numeric_exact_match(self): + """Test numeric exact matching.""" + assert gaia_scorer("42", "42") is True + assert gaia_scorer("42.0", "42") is True + assert gaia_scorer("42", "42.0") is True + assert gaia_scorer("42", "43") is False + + def test_string_normalization(self): + """Test string normalization and matching.""" + assert gaia_scorer("Hello World", "hello world") is True + assert gaia_scorer("Hello, World!", "helloworld") is True + assert gaia_scorer("test", "TEST") is True + assert gaia_scorer("test", "different") is False + + def test_list_matching(self): + """Test list matching with comma/semicolon separation.""" + assert gaia_scorer("1,2,3", "1,2,3") is True + assert gaia_scorer("1; 2; 3", "1,2,3") is True + assert gaia_scorer("apple,banana", "apple,banana") is True + assert gaia_scorer("1,2,3", "1,2,4") is False + assert gaia_scorer("1,2", "1,2,3") is False + + def test_none_handling(self): + """Test handling of None values.""" + assert gaia_scorer("None", "test") is False + assert gaia_scorer("", "test") is False diff --git a/python/packages/lab/lighting/LICENSE b/python/packages/lab/lighting/LICENSE new file mode 100644 index 0000000000..22aed37e65 --- /dev/null +++ b/python/packages/lab/lighting/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Microsoft Corporation. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/python/packages/lab/lighting/README.md b/python/packages/lab/lighting/README.md new file mode 100644 index 0000000000..5c5180843d --- /dev/null +++ b/python/packages/lab/lighting/README.md @@ -0,0 +1,56 @@ +# Agent Framework Lab - Agent Framework x Agent Lighting + +RL Module for Microsoft Agent Framework + +## Installation + +```bash +pip install agent-framework-lab-lighting +``` + +## Usage + +```python +from agent_framework.lab.lighting import YourClass + +# Your usage example here +instance = YourClass() +``` + +## Overview + +Brief description of what this lab package provides and its main features. + +## Features + +- Feature 1: Description +- Feature 2: Description +- Feature 3: Description + +## Examples + +### Basic Usage + +```python +from agent_framework.lab.lighting import YourClass + +# Example usage +``` + +### Advanced Usage + +```python +# More advanced examples +``` + +## API Reference + +Document your main classes and functions here. + +## Contributing + +This package is part of the Microsoft Agent Framework Lab. Please see the main repository for contribution guidelines. + +## License + +This project is licensed under the MIT License - see the LICENSE file for details. \ No newline at end of file diff --git a/python/packages/lab/lighting/agent_framework/__init__.py b/python/packages/lab/lighting/agent_framework/__init__.py new file mode 100644 index 0000000000..1d3db512a4 --- /dev/null +++ b/python/packages/lab/lighting/agent_framework/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/packages/lab/lighting/agent_framework/lab/__init__.py b/python/packages/lab/lighting/agent_framework/lab/__init__.py new file mode 100644 index 0000000000..0d8d8fbaa4 --- /dev/null +++ b/python/packages/lab/lighting/agent_framework/lab/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework.lab a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/packages/lab/lighting/agent_framework/lab/lighting/__init__.py b/python/packages/lab/lighting/agent_framework/lab/lighting/__init__.py new file mode 100644 index 0000000000..a0701eebba --- /dev/null +++ b/python/packages/lab/lighting/agent_framework/lab/lighting/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# Import and re-export from the actual implementation +from agent_framework_lab_lighting import * # noqa: F403, F401 diff --git a/python/packages/lab/lighting/agent_framework_lab_lighting/__init__.py b/python/packages/lab/lighting/agent_framework_lab_lighting/__init__.py new file mode 100644 index 0000000000..f3aac855ac --- /dev/null +++ b/python/packages/lab/lighting/agent_framework_lab_lighting/__init__.py @@ -0,0 +1,16 @@ +# Copyright (c) Microsoft. All rights reserved. + +""" +RL Module for Microsoft Agent Framework +""" + +# Import your main exports here +# from .main_module import MainClass, main_function + +__all__ = [ + # List your exports here + # "MainClass", + # "main_function", +] + +__version__ = "0.1.0b1" diff --git a/python/packages/lab/lighting/agent_framework_lab_lighting/py.typed b/python/packages/lab/lighting/agent_framework_lab_lighting/py.typed new file mode 100644 index 0000000000..e69de29bb2 diff --git a/python/packages/lab/lighting/pyproject.toml b/python/packages/lab/lighting/pyproject.toml new file mode 100644 index 0000000000..cf175b173b --- /dev/null +++ b/python/packages/lab/lighting/pyproject.toml @@ -0,0 +1,87 @@ +[project] +name = "agent-framework-lab-lighting" +description = "RL Module for Microsoft Agent Framework" +authors = [{ name = "Microsoft", email = "SK-Support@microsoft.com"}] +readme = "README.md" +requires-python = ">=3.10" +version = "0.1.0b1" +license-files = ["LICENSE"] +urls.homepage = "https://learn.microsoft.com/en-us/semantic-kernel/overview/" +urls.source = "https://github.com/microsoft/agent-framework/tree/main/python" +urls.release_notes = "https://github.com/microsoft/agent-framework/releases?q=tag%3Apython-1&expanded=true" +urls.issues = "https://github.com/microsoft/agent-framework/issues" +classifiers = [ + "License :: OSI Approved :: MIT License", + "Development Status :: 2 - Pre-Alpha", + "Intended Audience :: Developers", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", +] +dependencies = [ + "agent-framework", + "pydantic>=2.0.0", + # Add your specific dependencies here +] + + +[project.scripts] +lighting = "agent_framework_lab_lighting:main" + + +[build-system] +requires = ["setuptools>=64", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.setuptools] +packages = ["agent_framework_lab_lighting", "agent_framework.lab.lighting"] + +[tool.setuptools.package-data] +agent_framework_lab_lighting = ["py.typed"] + +[tool.ruff] +line-length = 120 +target-version = "py310" +extend-exclude = ["tests", "__pycache__"] + +[tool.ruff.lint] +select = ["E", "F", "I", "W", "UP", "C4", "N"] +ignore = ["N803", "N806", "N999", "UP007"] + +[tool.ruff.format] +quote-style = "double" + +[tool.mypy] +python_version = "3.10" +strict = true +check_untyped_defs = true +disallow_untyped_defs = true +disallow_incomplete_defs = true +disallow_untyped_decorators = true +warn_redundant_casts = true +warn_unused_ignores = true +warn_return_any = true +warn_unreachable = true +show_error_codes = true +implicit_reexport = true +packages = ["agent_framework_lab_lighting"] + + +[tool.poe] +executor.type = "uv" +include = "../../../shared_tasks.toml" +[tool.poe.tasks] +test = "pytest --cov=agent_framework_lab_lighting --cov-report=term-missing:skip-covered tests" +mypy = "mypy agent_framework_lab_lighting" + + +[tool.pytest.ini_options] +testpaths = ["tests"] +pythonpath = ["."] +addopts = "--strict-markers --strict-config" +markers = [ + "unit: marks tests as unit tests", + "integration: marks tests as integration tests", +] \ No newline at end of file diff --git a/python/packages/lab/lighting/tests/__init__.py b/python/packages/lab/lighting/tests/__init__.py new file mode 100644 index 0000000000..2a50eae894 --- /dev/null +++ b/python/packages/lab/lighting/tests/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Microsoft. All rights reserved. diff --git a/python/packages/lab/lighting/tests/test_lighting.py b/python/packages/lab/lighting/tests/test_lighting.py new file mode 100644 index 0000000000..347b14f3de --- /dev/null +++ b/python/packages/lab/lighting/tests/test_lighting.py @@ -0,0 +1,15 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Tests for lighting module.""" + +import pytest +from agent_framework_lab_lighting import __version__ + + +class TestLighting: + """Test the lighting module.""" + + def test_version(self): + """Test package version is defined.""" + assert __version__ is not None + assert __version__ == "0.1.0b1" diff --git a/python/packages/main/agent_framework/lab/__init__.py b/python/packages/main/agent_framework/lab/__init__.py new file mode 100644 index 0000000000..0d8d8fbaa4 --- /dev/null +++ b/python/packages/main/agent_framework/lab/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft. All rights reserved. + +# This makes agent_framework.lab a namespace package +__path__ = __import__("pkgutil").extend_path(__path__, __name__) diff --git a/python/pyproject.toml b/python/pyproject.toml index d35badb111..291a5613a5 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -9,6 +9,7 @@ dependencies = [ "agent-framework-copilotstudio", "agent-framework-foundry", "agent-framework-mem0", + "agent-framework-lab-gaia", ] [dependency-groups] @@ -46,14 +47,15 @@ environments = [ ] [tool.uv.workspace] -members = [ "packages/*" ] -exclude = [ "packages/agent_framework_project.egg-info" ] +members = [ "packages/*", "packages/lab/*" ] +exclude = [ "packages/agent_framework_project.egg-info", "packages/lab", "packages/lab/cookiecutter-agent-framework-lab", "packages/lab/README.md" ] [tool.uv.sources] agent-framework = { workspace = true } agent-framework-azure = { workspace = true } agent-framework-copilotstudio = { workspace = true } agent-framework-foundry = { workspace = true } +agent-framework-lab-gaia = { workspace = true } agent-framework-mem0 = { workspace = true } agent-framework-runtime = { workspace = true } @@ -162,7 +164,7 @@ exclude_dirs = ["tests", "./run_tasks_in_packages_if_exists.py", "./check_md_cod executor.type = "uv" [tool.poe.tasks] -markdown-code-lint = """python check_md_code_blocks.py README.md ./packages/**/README.md ./samples/**/*.md""" +markdown-code-lint = """uv run python check_md_code_blocks.py README.md ./packages/**/README.md ./samples/**/*.md --exclude cookiecutter-agent-framework-lab""" samples-code-check = """pyright ./samples""" docs-install = "uv sync --all-packages --all-extras --dev -U --prerelease=if-necessary-or-explicit --group=docs" docs-clean = "rm -rf docs/build" diff --git a/python/uv.lock b/python/uv.lock index 06a3ee6a41..cf17808486 100644 --- a/python/uv.lock +++ b/python/uv.lock @@ -27,6 +27,8 @@ members = [ "agent-framework-azure", "agent-framework-copilotstudio", "agent-framework-foundry", + "agent-framework-lab-gaia", + "agent-framework-lab-lighting", "agent-framework-mem0", "agent-framework-project", "agent-framework-runtime", @@ -149,6 +151,44 @@ requires-dist = [ { name = "azure-ai-projects", specifier = ">=1.0.0b11" }, ] +[[package]] +name = "agent-framework-lab-gaia" +version = "0.1.0b1" +source = { editable = "packages/lab/gaia" } +dependencies = [ + { name = "agent-framework", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "huggingface-hub", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "orjson", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, +] + +[package.metadata] +requires-dist = [ + { name = "agent-framework", editable = "packages/main" }, + { name = "huggingface-hub", specifier = ">=0.20.0" }, + { name = "opentelemetry-api", specifier = ">=1.24.0" }, + { name = "orjson", specifier = ">=3.8.0" }, + { name = "pydantic", specifier = ">=2.0.0" }, + { name = "tqdm", specifier = ">=4.60.0" }, +] + +[[package]] +name = "agent-framework-lab-lighting" +version = "0.1.0b1" +source = { editable = "packages/lab/lighting" } +dependencies = [ + { name = "agent-framework", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, +] + +[package.metadata] +requires-dist = [ + { name = "agent-framework", editable = "packages/main" }, + { name = "pydantic", specifier = ">=2.0.0" }, +] + [[package]] name = "agent-framework-mem0" version = "0.1.0b1" @@ -173,6 +213,7 @@ dependencies = [ { name = "agent-framework-azure", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "agent-framework-copilotstudio", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "agent-framework-foundry", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "agent-framework-lab-gaia", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "agent-framework-mem0", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] @@ -205,6 +246,7 @@ requires-dist = [ { name = "agent-framework-azure", editable = "packages/azure" }, { name = "agent-framework-copilotstudio", editable = "packages/copilotstudio" }, { name = "agent-framework-foundry", editable = "packages/foundry" }, + { name = "agent-framework-lab-gaia", editable = "packages/lab/gaia" }, { name = "agent-framework-mem0", editable = "packages/mem0" }, ] @@ -497,7 +539,7 @@ wheels = [ [[package]] name = "azure-monitor-opentelemetry" -version = "1.8.0" +version = "1.8.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "azure-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -513,14 +555,14 @@ dependencies = [ { name = "opentelemetry-resource-detector-azure", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-sdk", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a9/52/e83417a7932b104dec0423697b1d9558fde5bdbbe5e8c24c61faee200841/azure_monitor_opentelemetry-1.8.0.tar.gz", hash = "sha256:25623a69e208e6fdf869c0fbfd98c4b2661a7eb412d098b632e7bbd047921fe1", size = 53323, upload-time = "2025-09-08T20:21:32.409Z" } +sdist = { url = "https://files.pythonhosted.org/packages/55/ae/eae89705498c975b1cfcc2ce0e5bfbe784a47ffd54cef6fbebe31fdb2295/azure_monitor_opentelemetry-1.8.1.tar.gz", hash = "sha256:9b93b62868775d74db60d9e997cfccc5898260c5de23278d7e99cce3764e9fda", size = 53471, upload-time = "2025-09-16T20:30:22.587Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4a/46/356ffdc784d174b632afa82f036369be95f66a6df9360a51537596acc81d/azure_monitor_opentelemetry-1.8.0-py3-none-any.whl", hash = "sha256:b57846a4a325f580d47f24b3f9e7b165b2d8d9524e53618ec941ec133e2d4b09", size = 27168, upload-time = "2025-09-08T20:21:34.058Z" }, + { url = "https://files.pythonhosted.org/packages/85/ab/d063f5d0debbb01ef716789f5b4b315d58f657dd5dbf15e47ca6648a557b/azure_monitor_opentelemetry-1.8.1-py3-none-any.whl", hash = "sha256:bebca6af9d81ddc52df59b281a5acc84182bbf1cbccd6f843a2074f6e283947e", size = 27169, upload-time = "2025-09-16T20:30:23.794Z" }, ] [[package]] name = "azure-monitor-opentelemetry-exporter" -version = "1.0.0b41" +version = "1.0.0b42" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "azure-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -531,9 +573,9 @@ dependencies = [ { name = "opentelemetry-sdk", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "psutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6c/c3/2f18eaed17a40982ad04953ad0fa5b1a2dbc5a5c98b6d3ef68c1d7d285ae/azure_monitor_opentelemetry_exporter-1.0.0b41.tar.gz", hash = "sha256:b363e6f89c0dee16d02782a310a60d626e4c081ef49d533ff5225a40cbab12cc", size = 206710, upload-time = "2025-07-31T22:37:28.378Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/d9/ed8c3a4ad8ae2ab8745d940305ca8ec41208dfdefa6a7a232ab62ffe40a3/azure_monitor_opentelemetry_exporter-1.0.0b42.tar.gz", hash = "sha256:d35b60e0404446932e31e3a0b1c2202e47e9b78f91bb24110bd164aa62c5bb87", size = 245626, upload-time = "2025-09-16T23:50:16.457Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/50/d4/8cc989c4eedcefb74dccdd5af2faf51e0237163f538d2b258eef7e35f33d/azure_monitor_opentelemetry_exporter-1.0.0b41-py2.py3-none-any.whl", hash = "sha256:cbba629cca53e0e33416c61e08ebaabe833e740cfbfd7f2e9151821f92c66a51", size = 162631, upload-time = "2025-07-31T22:37:29.809Z" }, + { url = "https://files.pythonhosted.org/packages/86/c9/d6050a53565f3653205fad79d53982411530b80a72ee1352110c0c0cd0fe/azure_monitor_opentelemetry_exporter-1.0.0b42-py2.py3-none-any.whl", hash = "sha256:649d8a634c119ae942d2dd20ff3006dda88050d3c7044b09bd5111e66439833e", size = 183324, upload-time = "2025-09-16T23:50:18.32Z" }, ] [[package]] @@ -855,49 +897,67 @@ toml = [ [[package]] name = "cryptography" -version = "45.0.7" +version = "46.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cffi", marker = "(platform_python_implementation != 'PyPy' and sys_platform == 'darwin') or (platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (platform_python_implementation != 'PyPy' and sys_platform == 'win32')" }, + { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform == 'win32')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a7/35/c495bffc2056f2dadb32434f1feedd79abde2a7f8363e1974afa9c33c7e2/cryptography-45.0.7.tar.gz", hash = "sha256:4b1654dfc64ea479c242508eb8c724044f1e964a47d1d1cacc5132292d851971", size = 744980, upload-time = "2025-09-01T11:15:03.146Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/62/e3664e6ffd7743e1694b244dde70b43a394f6f7fbcacf7014a8ff5197c73/cryptography-46.0.1.tar.gz", hash = "sha256:ed570874e88f213437f5cf758f9ef26cbfc3f336d889b1e592ee11283bb8d1c7", size = 749198, upload-time = "2025-09-17T00:10:35.797Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/91/925c0ac74362172ae4516000fe877912e33b5983df735ff290c653de4913/cryptography-45.0.7-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:3be4f21c6245930688bd9e162829480de027f8bf962ede33d4f8ba7d67a00cee", size = 7041105, upload-time = "2025-09-01T11:13:59.684Z" }, - { url = "https://files.pythonhosted.org/packages/fc/63/43641c5acce3a6105cf8bd5baeceeb1846bb63067d26dae3e5db59f1513a/cryptography-45.0.7-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:67285f8a611b0ebc0857ced2081e30302909f571a46bfa7a3cc0ad303fe015c6", size = 4205799, upload-time = "2025-09-01T11:14:02.517Z" }, - { url = "https://files.pythonhosted.org/packages/bc/29/c238dd9107f10bfde09a4d1c52fd38828b1aa353ced11f358b5dd2507d24/cryptography-45.0.7-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:577470e39e60a6cd7780793202e63536026d9b8641de011ed9d8174da9ca5339", size = 4430504, upload-time = "2025-09-01T11:14:04.522Z" }, - { url = "https://files.pythonhosted.org/packages/62/62/24203e7cbcc9bd7c94739428cd30680b18ae6b18377ae66075c8e4771b1b/cryptography-45.0.7-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4bd3e5c4b9682bc112d634f2c6ccc6736ed3635fc3319ac2bb11d768cc5a00d8", size = 4209542, upload-time = "2025-09-01T11:14:06.309Z" }, - { url = "https://files.pythonhosted.org/packages/cd/e3/e7de4771a08620eef2389b86cd87a2c50326827dea5528feb70595439ce4/cryptography-45.0.7-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:465ccac9d70115cd4de7186e60cfe989de73f7bb23e8a7aa45af18f7412e75bf", size = 3889244, upload-time = "2025-09-01T11:14:08.152Z" }, - { url = "https://files.pythonhosted.org/packages/96/b8/bca71059e79a0bb2f8e4ec61d9c205fbe97876318566cde3b5092529faa9/cryptography-45.0.7-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:16ede8a4f7929b4b7ff3642eba2bf79aa1d71f24ab6ee443935c0d269b6bc513", size = 4461975, upload-time = "2025-09-01T11:14:09.755Z" }, - { url = "https://files.pythonhosted.org/packages/58/67/3f5b26937fe1218c40e95ef4ff8d23c8dc05aa950d54200cc7ea5fb58d28/cryptography-45.0.7-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:8978132287a9d3ad6b54fcd1e08548033cc09dc6aacacb6c004c73c3eb5d3ac3", size = 4209082, upload-time = "2025-09-01T11:14:11.229Z" }, - { url = "https://files.pythonhosted.org/packages/0e/e4/b3e68a4ac363406a56cf7b741eeb80d05284d8c60ee1a55cdc7587e2a553/cryptography-45.0.7-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b6a0e535baec27b528cb07a119f321ac024592388c5681a5ced167ae98e9fff3", size = 4460397, upload-time = "2025-09-01T11:14:12.924Z" }, - { url = "https://files.pythonhosted.org/packages/22/49/2c93f3cd4e3efc8cb22b02678c1fad691cff9dd71bb889e030d100acbfe0/cryptography-45.0.7-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a24ee598d10befaec178efdff6054bc4d7e883f615bfbcd08126a0f4931c83a6", size = 4337244, upload-time = "2025-09-01T11:14:14.431Z" }, - { url = "https://files.pythonhosted.org/packages/04/19/030f400de0bccccc09aa262706d90f2ec23d56bc4eb4f4e8268d0ddf3fb8/cryptography-45.0.7-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:fa26fa54c0a9384c27fcdc905a2fb7d60ac6e47d14bc2692145f2b3b1e2cfdbd", size = 4568862, upload-time = "2025-09-01T11:14:16.185Z" }, - { url = "https://files.pythonhosted.org/packages/29/56/3034a3a353efa65116fa20eb3c990a8c9f0d3db4085429040a7eef9ada5f/cryptography-45.0.7-cp311-abi3-win32.whl", hash = "sha256:bef32a5e327bd8e5af915d3416ffefdbe65ed975b646b3805be81b23580b57b8", size = 2936578, upload-time = "2025-09-01T11:14:17.638Z" }, - { url = "https://files.pythonhosted.org/packages/b3/61/0ab90f421c6194705a99d0fa9f6ee2045d916e4455fdbb095a9c2c9a520f/cryptography-45.0.7-cp311-abi3-win_amd64.whl", hash = "sha256:3808e6b2e5f0b46d981c24d79648e5c25c35e59902ea4391a0dcb3e667bf7443", size = 3405400, upload-time = "2025-09-01T11:14:18.958Z" }, - { url = "https://files.pythonhosted.org/packages/63/e8/c436233ddf19c5f15b25ace33979a9dd2e7aa1a59209a0ee8554179f1cc0/cryptography-45.0.7-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:bfb4c801f65dd61cedfc61a83732327fafbac55a47282e6f26f073ca7a41c3b2", size = 7021824, upload-time = "2025-09-01T11:14:20.954Z" }, - { url = "https://files.pythonhosted.org/packages/bc/4c/8f57f2500d0ccd2675c5d0cc462095adf3faa8c52294ba085c036befb901/cryptography-45.0.7-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:81823935e2f8d476707e85a78a405953a03ef7b7b4f55f93f7c2d9680e5e0691", size = 4202233, upload-time = "2025-09-01T11:14:22.454Z" }, - { url = "https://files.pythonhosted.org/packages/eb/ac/59b7790b4ccaed739fc44775ce4645c9b8ce54cbec53edf16c74fd80cb2b/cryptography-45.0.7-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3994c809c17fc570c2af12c9b840d7cea85a9fd3e5c0e0491f4fa3c029216d59", size = 4423075, upload-time = "2025-09-01T11:14:24.287Z" }, - { url = "https://files.pythonhosted.org/packages/b8/56/d4f07ea21434bf891faa088a6ac15d6d98093a66e75e30ad08e88aa2b9ba/cryptography-45.0.7-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dad43797959a74103cb59c5dac71409f9c27d34c8a05921341fb64ea8ccb1dd4", size = 4204517, upload-time = "2025-09-01T11:14:25.679Z" }, - { url = "https://files.pythonhosted.org/packages/e8/ac/924a723299848b4c741c1059752c7cfe09473b6fd77d2920398fc26bfb53/cryptography-45.0.7-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ce7a453385e4c4693985b4a4a3533e041558851eae061a58a5405363b098fcd3", size = 3882893, upload-time = "2025-09-01T11:14:27.1Z" }, - { url = "https://files.pythonhosted.org/packages/83/dc/4dab2ff0a871cc2d81d3ae6d780991c0192b259c35e4d83fe1de18b20c70/cryptography-45.0.7-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:b04f85ac3a90c227b6e5890acb0edbaf3140938dbecf07bff618bf3638578cf1", size = 4450132, upload-time = "2025-09-01T11:14:28.58Z" }, - { url = "https://files.pythonhosted.org/packages/12/dd/b2882b65db8fc944585d7fb00d67cf84a9cef4e77d9ba8f69082e911d0de/cryptography-45.0.7-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:48c41a44ef8b8c2e80ca4527ee81daa4c527df3ecbc9423c41a420a9559d0e27", size = 4204086, upload-time = "2025-09-01T11:14:30.572Z" }, - { url = "https://files.pythonhosted.org/packages/5d/fa/1d5745d878048699b8eb87c984d4ccc5da4f5008dfd3ad7a94040caca23a/cryptography-45.0.7-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f3df7b3d0f91b88b2106031fd995802a2e9ae13e02c36c1fc075b43f420f3a17", size = 4449383, upload-time = "2025-09-01T11:14:32.046Z" }, - { url = "https://files.pythonhosted.org/packages/36/8b/fc61f87931bc030598e1876c45b936867bb72777eac693e905ab89832670/cryptography-45.0.7-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dd342f085542f6eb894ca00ef70236ea46070c8a13824c6bde0dfdcd36065b9b", size = 4332186, upload-time = "2025-09-01T11:14:33.95Z" }, - { url = "https://files.pythonhosted.org/packages/0b/11/09700ddad7443ccb11d674efdbe9a832b4455dc1f16566d9bd3834922ce5/cryptography-45.0.7-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1993a1bb7e4eccfb922b6cd414f072e08ff5816702a0bdb8941c247a6b1b287c", size = 4561639, upload-time = "2025-09-01T11:14:35.343Z" }, - { url = "https://files.pythonhosted.org/packages/71/ed/8f4c1337e9d3b94d8e50ae0b08ad0304a5709d483bfcadfcc77a23dbcb52/cryptography-45.0.7-cp37-abi3-win32.whl", hash = "sha256:18fcf70f243fe07252dcb1b268a687f2358025ce32f9f88028ca5c364b123ef5", size = 2926552, upload-time = "2025-09-01T11:14:36.929Z" }, - { url = "https://files.pythonhosted.org/packages/bc/ff/026513ecad58dacd45d1d24ebe52b852165a26e287177de1d545325c0c25/cryptography-45.0.7-cp37-abi3-win_amd64.whl", hash = "sha256:7285a89df4900ed3bfaad5679b1e668cb4b38a8de1ccbfc84b05f34512da0a90", size = 3392742, upload-time = "2025-09-01T11:14:38.368Z" }, - { url = "https://files.pythonhosted.org/packages/13/3e/e42f1528ca1ea82256b835191eab1be014e0f9f934b60d98b0be8a38ed70/cryptography-45.0.7-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:de58755d723e86175756f463f2f0bddd45cc36fbd62601228a3f8761c9f58252", size = 3572442, upload-time = "2025-09-01T11:14:39.836Z" }, - { url = "https://files.pythonhosted.org/packages/59/aa/e947693ab08674a2663ed2534cd8d345cf17bf6a1facf99273e8ec8986dc/cryptography-45.0.7-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a20e442e917889d1a6b3c570c9e3fa2fdc398c20868abcea268ea33c024c4083", size = 4142233, upload-time = "2025-09-01T11:14:41.305Z" }, - { url = "https://files.pythonhosted.org/packages/24/06/09b6f6a2fc43474a32b8fe259038eef1500ee3d3c141599b57ac6c57612c/cryptography-45.0.7-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:258e0dff86d1d891169b5af222d362468a9570e2532923088658aa866eb11130", size = 4376202, upload-time = "2025-09-01T11:14:43.047Z" }, - { url = "https://files.pythonhosted.org/packages/00/f2/c166af87e95ce6ae6d38471a7e039d3a0549c2d55d74e059680162052824/cryptography-45.0.7-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d97cf502abe2ab9eff8bd5e4aca274da8d06dd3ef08b759a8d6143f4ad65d4b4", size = 4141900, upload-time = "2025-09-01T11:14:45.089Z" }, - { url = "https://files.pythonhosted.org/packages/16/b9/e96e0b6cb86eae27ea51fa8a3151535a18e66fe7c451fa90f7f89c85f541/cryptography-45.0.7-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:c987dad82e8c65ebc985f5dae5e74a3beda9d0a2a4daf8a1115f3772b59e5141", size = 4375562, upload-time = "2025-09-01T11:14:47.166Z" }, - { url = "https://files.pythonhosted.org/packages/36/d0/36e8ee39274e9d77baf7d0dafda680cba6e52f3936b846f0d56d64fec915/cryptography-45.0.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c13b1e3afd29a5b3b2656257f14669ca8fa8d7956d509926f0b130b600b50ab7", size = 3322781, upload-time = "2025-09-01T11:14:48.747Z" }, - { url = "https://files.pythonhosted.org/packages/99/4e/49199a4c82946938a3e05d2e8ad9482484ba48bbc1e809e3d506c686d051/cryptography-45.0.7-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4a862753b36620af6fc54209264f92c716367f2f0ff4624952276a6bbd18cbde", size = 3584634, upload-time = "2025-09-01T11:14:50.593Z" }, - { url = "https://files.pythonhosted.org/packages/16/ce/5f6ff59ea9c7779dba51b84871c19962529bdcc12e1a6ea172664916c550/cryptography-45.0.7-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:06ce84dc14df0bf6ea84666f958e6080cdb6fe1231be2a51f3fc1267d9f3fb34", size = 4149533, upload-time = "2025-09-01T11:14:52.091Z" }, - { url = "https://files.pythonhosted.org/packages/ce/13/b3cfbd257ac96da4b88b46372e662009b7a16833bfc5da33bb97dd5631ae/cryptography-45.0.7-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d0c5c6bac22b177bf8da7435d9d27a6834ee130309749d162b26c3105c0795a9", size = 4385557, upload-time = "2025-09-01T11:14:53.551Z" }, - { url = "https://files.pythonhosted.org/packages/1c/c5/8c59d6b7c7b439ba4fc8d0cab868027fd095f215031bc123c3a070962912/cryptography-45.0.7-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:2f641b64acc00811da98df63df7d59fd4706c0df449da71cb7ac39a0732b40ae", size = 4149023, upload-time = "2025-09-01T11:14:55.022Z" }, - { url = "https://files.pythonhosted.org/packages/55/32/05385c86d6ca9ab0b4d5bb442d2e3d85e727939a11f3e163fc776ce5eb40/cryptography-45.0.7-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:f5414a788ecc6ee6bc58560e85ca624258a55ca434884445440a810796ea0e0b", size = 4385722, upload-time = "2025-09-01T11:14:57.319Z" }, - { url = "https://files.pythonhosted.org/packages/23/87/7ce86f3fa14bc11a5a48c30d8103c26e09b6465f8d8e9d74cf7a0714f043/cryptography-45.0.7-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:1f3d56f73595376f4244646dd5c5870c14c196949807be39e79e7bd9bac3da63", size = 3332908, upload-time = "2025-09-01T11:14:58.78Z" }, + { url = "https://files.pythonhosted.org/packages/4c/8c/44ee01267ec01e26e43ebfdae3f120ec2312aa72fa4c0507ebe41a26739f/cryptography-46.0.1-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:1cd6d50c1a8b79af1a6f703709d8973845f677c8e97b1268f5ff323d38ce8475", size = 7285044, upload-time = "2025-09-17T00:08:36.807Z" }, + { url = "https://files.pythonhosted.org/packages/22/59/9ae689a25047e0601adfcb159ec4f83c0b4149fdb5c3030cc94cd218141d/cryptography-46.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0ff483716be32690c14636e54a1f6e2e1b7bf8e22ca50b989f88fa1b2d287080", size = 4308182, upload-time = "2025-09-17T00:08:39.388Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ee/ca6cc9df7118f2fcd142c76b1da0f14340d77518c05b1ebfbbabca6b9e7d/cryptography-46.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9873bf7c1f2a6330bdfe8621e7ce64b725784f9f0c3a6a55c3047af5849f920e", size = 4572393, upload-time = "2025-09-17T00:08:41.663Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a3/0f5296f63815d8e985922b05c31f77ce44787b3127a67c0b7f70f115c45f/cryptography-46.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0dfb7c88d4462a0cfdd0d87a3c245a7bc3feb59de101f6ff88194f740f72eda6", size = 4308400, upload-time = "2025-09-17T00:08:43.559Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8c/74fcda3e4e01be1d32775d5b4dd841acaac3c1b8fa4d0774c7ac8d52463d/cryptography-46.0.1-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e22801b61613ebdebf7deb18b507919e107547a1d39a3b57f5f855032dd7cfb8", size = 4015786, upload-time = "2025-09-17T00:08:45.758Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b8/85d23287baeef273b0834481a3dd55bbed3a53587e3b8d9f0898235b8f91/cryptography-46.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:757af4f6341ce7a1e47c326ca2a81f41d236070217e5fbbad61bbfe299d55d28", size = 4982606, upload-time = "2025-09-17T00:08:47.602Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d3/de61ad5b52433b389afca0bc70f02a7a1f074651221f599ce368da0fe437/cryptography-46.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f7a24ea78de345cfa7f6a8d3bde8b242c7fac27f2bd78fa23474ca38dfaeeab9", size = 4604234, upload-time = "2025-09-17T00:08:49.879Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1f/dbd4d6570d84748439237a7478d124ee0134bf166ad129267b7ed8ea6d22/cryptography-46.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:9e8776dac9e660c22241b6587fae51a67b4b0147daa4d176b172c3ff768ad736", size = 4307669, upload-time = "2025-09-17T00:08:52.321Z" }, + { url = "https://files.pythonhosted.org/packages/ec/fd/ca0a14ce7f0bfe92fa727aacaf2217eb25eb7e4ed513b14d8e03b26e63ed/cryptography-46.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9f40642a140c0c8649987027867242b801486865277cbabc8c6059ddef16dc8b", size = 4947579, upload-time = "2025-09-17T00:08:54.697Z" }, + { url = "https://files.pythonhosted.org/packages/89/6b/09c30543bb93401f6f88fce556b3bdbb21e55ae14912c04b7bf355f5f96c/cryptography-46.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:449ef2b321bec7d97ef2c944173275ebdab78f3abdd005400cc409e27cd159ab", size = 4603669, upload-time = "2025-09-17T00:08:57.16Z" }, + { url = "https://files.pythonhosted.org/packages/23/9a/38cb01cb09ce0adceda9fc627c9cf98eb890fc8d50cacbe79b011df20f8a/cryptography-46.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2dd339ba3345b908fa3141ddba4025568fa6fd398eabce3ef72a29ac2d73ad75", size = 4435828, upload-time = "2025-09-17T00:08:59.606Z" }, + { url = "https://files.pythonhosted.org/packages/0f/53/435b5c36a78d06ae0bef96d666209b0ecd8f8181bfe4dda46536705df59e/cryptography-46.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7411c910fb2a412053cf33cfad0153ee20d27e256c6c3f14d7d7d1d9fec59fd5", size = 4709553, upload-time = "2025-09-17T00:09:01.832Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c4/0da6e55595d9b9cd3b6eb5dc22f3a07ded7f116a3ea72629cab595abb804/cryptography-46.0.1-cp311-abi3-win32.whl", hash = "sha256:cbb8e769d4cac884bb28e3ff620ef1001b75588a5c83c9c9f1fdc9afbe7f29b0", size = 3058327, upload-time = "2025-09-17T00:09:03.726Z" }, + { url = "https://files.pythonhosted.org/packages/95/0f/cd29a35e0d6e78a0ee61793564c8cff0929c38391cb0de27627bdc7525aa/cryptography-46.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:92e8cfe8bd7dd86eac0a677499894862cd5cc2fd74de917daa881d00871ac8e7", size = 3523893, upload-time = "2025-09-17T00:09:06.272Z" }, + { url = "https://files.pythonhosted.org/packages/f2/dd/eea390f3e78432bc3d2f53952375f8b37cb4d37783e626faa6a51e751719/cryptography-46.0.1-cp311-abi3-win_arm64.whl", hash = "sha256:db5597a4c7353b2e5fb05a8e6cb74b56a4658a2b7bf3cb6b1821ae7e7fd6eaa0", size = 2932145, upload-time = "2025-09-17T00:09:08.568Z" }, + { url = "https://files.pythonhosted.org/packages/0a/fb/c73588561afcd5e24b089952bd210b14676c0c5bf1213376350ae111945c/cryptography-46.0.1-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:4c49eda9a23019e11d32a0eb51a27b3e7ddedde91e099c0ac6373e3aacc0d2ee", size = 7193928, upload-time = "2025-09-17T00:09:10.595Z" }, + { url = "https://files.pythonhosted.org/packages/26/34/0ff0bb2d2c79f25a2a63109f3b76b9108a906dd2a2eb5c1d460b9938adbb/cryptography-46.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9babb7818fdd71394e576cf26c5452df77a355eac1a27ddfa24096665a27f8fd", size = 4293515, upload-time = "2025-09-17T00:09:12.861Z" }, + { url = "https://files.pythonhosted.org/packages/df/b7/d4f848aee24ecd1be01db6c42c4a270069a4f02a105d9c57e143daf6cf0f/cryptography-46.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9f2c4cc63be3ef43c0221861177cee5d14b505cd4d4599a89e2cd273c4d3542a", size = 4545619, upload-time = "2025-09-17T00:09:15.397Z" }, + { url = "https://files.pythonhosted.org/packages/44/a5/42fedefc754fd1901e2d95a69815ea4ec8a9eed31f4c4361fcab80288661/cryptography-46.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:41c281a74df173876da1dc9a9b6953d387f06e3d3ed9284e3baae3ab3f40883a", size = 4299160, upload-time = "2025-09-17T00:09:17.155Z" }, + { url = "https://files.pythonhosted.org/packages/86/a1/cd21174f56e769c831fbbd6399a1b7519b0ff6280acec1b826d7b072640c/cryptography-46.0.1-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0a17377fa52563d730248ba1f68185461fff36e8bc75d8787a7dd2e20a802b7a", size = 3994491, upload-time = "2025-09-17T00:09:18.971Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/a8cbfa1c029987ddc746fd966711d4fa71efc891d37fbe9f030fe5ab4eec/cryptography-46.0.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:0d1922d9280e08cde90b518a10cd66831f632960a8d08cb3418922d83fce6f12", size = 4960157, upload-time = "2025-09-17T00:09:20.923Z" }, + { url = "https://files.pythonhosted.org/packages/67/ae/63a84e6789e0d5a2502edf06b552bcb0fa9ff16147265d5c44a211942abe/cryptography-46.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:af84e8e99f1a82cea149e253014ea9dc89f75b82c87bb6c7242203186f465129", size = 4577263, upload-time = "2025-09-17T00:09:23.356Z" }, + { url = "https://files.pythonhosted.org/packages/ef/8f/1b9fa8e92bd9cbcb3b7e1e593a5232f2c1e6f9bd72b919c1a6b37d315f92/cryptography-46.0.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:ef648d2c690703501714588b2ba640facd50fd16548133b11b2859e8655a69da", size = 4298703, upload-time = "2025-09-17T00:09:25.566Z" }, + { url = "https://files.pythonhosted.org/packages/c3/af/bb95db070e73fea3fae31d8a69ac1463d89d1c084220f549b00dd01094a8/cryptography-46.0.1-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:e94eb5fa32a8a9f9bf991f424f002913e3dd7c699ef552db9b14ba6a76a6313b", size = 4926363, upload-time = "2025-09-17T00:09:27.451Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3b/d8fb17ffeb3a83157a1cc0aa5c60691d062aceecba09c2e5e77ebfc1870c/cryptography-46.0.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:534b96c0831855e29fc3b069b085fd185aa5353033631a585d5cd4dd5d40d657", size = 4576958, upload-time = "2025-09-17T00:09:29.924Z" }, + { url = "https://files.pythonhosted.org/packages/d9/46/86bc3a05c10c8aa88c8ae7e953a8b4e407c57823ed201dbcba55c4d655f4/cryptography-46.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9b55038b5c6c47559aa33626d8ecd092f354e23de3c6975e4bb205df128a2a0", size = 4422507, upload-time = "2025-09-17T00:09:32.222Z" }, + { url = "https://files.pythonhosted.org/packages/a8/4e/387e5a21dfd2b4198e74968a541cfd6128f66f8ec94ed971776e15091ac3/cryptography-46.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ec13b7105117dbc9afd023300fb9954d72ca855c274fe563e72428ece10191c0", size = 4683964, upload-time = "2025-09-17T00:09:34.118Z" }, + { url = "https://files.pythonhosted.org/packages/25/a3/f9f5907b166adb8f26762071474b38bbfcf89858a5282f032899075a38a1/cryptography-46.0.1-cp314-cp314t-win32.whl", hash = "sha256:504e464944f2c003a0785b81668fe23c06f3b037e9cb9f68a7c672246319f277", size = 3029705, upload-time = "2025-09-17T00:09:36.381Z" }, + { url = "https://files.pythonhosted.org/packages/12/66/4d3a4f1850db2e71c2b1628d14b70b5e4c1684a1bd462f7fffb93c041c38/cryptography-46.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c52fded6383f7e20eaf70a60aeddd796b3677c3ad2922c801be330db62778e05", size = 3502175, upload-time = "2025-09-17T00:09:38.261Z" }, + { url = "https://files.pythonhosted.org/packages/52/c7/9f10ad91435ef7d0d99a0b93c4360bea3df18050ff5b9038c489c31ac2f5/cryptography-46.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:9495d78f52c804b5ec8878b5b8c7873aa8e63db9cd9ee387ff2db3fffe4df784", size = 2912354, upload-time = "2025-09-17T00:09:40.078Z" }, + { url = "https://files.pythonhosted.org/packages/98/e5/fbd632385542a3311915976f88e0dfcf09e62a3fc0aff86fb6762162a24d/cryptography-46.0.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:d84c40bdb8674c29fa192373498b6cb1e84f882889d21a471b45d1f868d8d44b", size = 7255677, upload-time = "2025-09-17T00:09:42.407Z" }, + { url = "https://files.pythonhosted.org/packages/56/3e/13ce6eab9ad6eba1b15a7bd476f005a4c1b3f299f4c2f32b22408b0edccf/cryptography-46.0.1-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9ed64e5083fa806709e74fc5ea067dfef9090e5b7a2320a49be3c9df3583a2d8", size = 4301110, upload-time = "2025-09-17T00:09:45.614Z" }, + { url = "https://files.pythonhosted.org/packages/a2/67/65dc233c1ddd688073cf7b136b06ff4b84bf517ba5529607c9d79720fc67/cryptography-46.0.1-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:341fb7a26bc9d6093c1b124b9f13acc283d2d51da440b98b55ab3f79f2522ead", size = 4562369, upload-time = "2025-09-17T00:09:47.601Z" }, + { url = "https://files.pythonhosted.org/packages/17/db/d64ae4c6f4e98c3dac5bf35dd4d103f4c7c345703e43560113e5e8e31b2b/cryptography-46.0.1-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6ef1488967e729948d424d09c94753d0167ce59afba8d0f6c07a22b629c557b2", size = 4302126, upload-time = "2025-09-17T00:09:49.335Z" }, + { url = "https://files.pythonhosted.org/packages/3d/19/5f1eea17d4805ebdc2e685b7b02800c4f63f3dd46cfa8d4c18373fea46c8/cryptography-46.0.1-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7823bc7cdf0b747ecfb096d004cc41573c2f5c7e3a29861603a2871b43d3ef32", size = 4009431, upload-time = "2025-09-17T00:09:51.239Z" }, + { url = "https://files.pythonhosted.org/packages/81/b5/229ba6088fe7abccbfe4c5edb96c7a5ad547fac5fdd0d40aa6ea540b2985/cryptography-46.0.1-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:f736ab8036796f5a119ff8211deda416f8c15ce03776db704a7a4e17381cb2ef", size = 4980739, upload-time = "2025-09-17T00:09:54.181Z" }, + { url = "https://files.pythonhosted.org/packages/3a/9c/50aa38907b201e74bc43c572f9603fa82b58e831bd13c245613a23cff736/cryptography-46.0.1-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:e46710a240a41d594953012213ea8ca398cd2448fbc5d0f1be8160b5511104a0", size = 4592289, upload-time = "2025-09-17T00:09:56.731Z" }, + { url = "https://files.pythonhosted.org/packages/5a/33/229858f8a5bb22f82468bb285e9f4c44a31978d5f5830bb4ea1cf8a4e454/cryptography-46.0.1-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:84ef1f145de5aee82ea2447224dc23f065ff4cc5791bb3b506615957a6ba8128", size = 4301815, upload-time = "2025-09-17T00:09:58.548Z" }, + { url = "https://files.pythonhosted.org/packages/52/cb/b76b2c87fbd6ed4a231884bea3ce073406ba8e2dae9defad910d33cbf408/cryptography-46.0.1-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9394c7d5a7565ac5f7d9ba38b2617448eba384d7b107b262d63890079fad77ca", size = 4943251, upload-time = "2025-09-17T00:10:00.475Z" }, + { url = "https://files.pythonhosted.org/packages/94/0f/f66125ecf88e4cb5b8017ff43f3a87ede2d064cb54a1c5893f9da9d65093/cryptography-46.0.1-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:ed957044e368ed295257ae3d212b95456bd9756df490e1ac4538857f67531fcc", size = 4591247, upload-time = "2025-09-17T00:10:02.874Z" }, + { url = "https://files.pythonhosted.org/packages/f6/22/9f3134ae436b63b463cfdf0ff506a0570da6873adb4bf8c19b8a5b4bac64/cryptography-46.0.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f7de12fa0eee6234de9a9ce0ffcfa6ce97361db7a50b09b65c63ac58e5f22fc7", size = 4428534, upload-time = "2025-09-17T00:10:04.994Z" }, + { url = "https://files.pythonhosted.org/packages/89/39/e6042bcb2638650b0005c752c38ea830cbfbcbb1830e4d64d530000aa8dc/cryptography-46.0.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7fab1187b6c6b2f11a326f33b036f7168f5b996aedd0c059f9738915e4e8f53a", size = 4699541, upload-time = "2025-09-17T00:10:06.925Z" }, + { url = "https://files.pythonhosted.org/packages/68/46/753d457492d15458c7b5a653fc9a84a1c9c7a83af6ebdc94c3fc373ca6e8/cryptography-46.0.1-cp38-abi3-win32.whl", hash = "sha256:45f790934ac1018adeba46a0f7289b2b8fe76ba774a88c7f1922213a56c98bc1", size = 3043779, upload-time = "2025-09-17T00:10:08.951Z" }, + { url = "https://files.pythonhosted.org/packages/2f/50/b6f3b540c2f6ee712feeb5fa780bb11fad76634e71334718568e7695cb55/cryptography-46.0.1-cp38-abi3-win_amd64.whl", hash = "sha256:7176a5ab56fac98d706921f6416a05e5aff7df0e4b91516f450f8627cda22af3", size = 3517226, upload-time = "2025-09-17T00:10:10.769Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e8/77d17d00981cdd27cc493e81e1749a0b8bbfb843780dbd841e30d7f50743/cryptography-46.0.1-cp38-abi3-win_arm64.whl", hash = "sha256:efc9e51c3e595267ff84adf56e9b357db89ab2279d7e375ffcaf8f678606f3d9", size = 2923149, upload-time = "2025-09-17T00:10:13.236Z" }, + { url = "https://files.pythonhosted.org/packages/14/b9/b260180b31a66859648cfed5c980544ee22b15f8bd20ef82a23f58c0b83e/cryptography-46.0.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd4b5e2ee4e60425711ec65c33add4e7a626adef79d66f62ba0acfd493af282d", size = 3714683, upload-time = "2025-09-17T00:10:15.601Z" }, + { url = "https://files.pythonhosted.org/packages/c5/5a/1cd3ef86e5884edcbf8b27c3aa8f9544e9b9fcce5d3ed8b86959741f4f8e/cryptography-46.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:48948940d0ae00483e85e9154bb42997d0b77c21e43a77b7773c8c80de532ac5", size = 3443784, upload-time = "2025-09-17T00:10:18.014Z" }, + { url = "https://files.pythonhosted.org/packages/27/27/077e09fd92075dd1338ea0ffaf5cfee641535545925768350ad90d8c36ca/cryptography-46.0.1-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:b9c79af2c3058430d911ff1a5b2b96bbfe8da47d5ed961639ce4681886614e70", size = 3722319, upload-time = "2025-09-17T00:10:20.273Z" }, + { url = "https://files.pythonhosted.org/packages/db/32/6fc7250280920418651640d76cee34d91c1e0601d73acd44364570cf041f/cryptography-46.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:0ca4be2af48c24df689a150d9cd37404f689e2968e247b6b8ff09bff5bcd786f", size = 4249030, upload-time = "2025-09-17T00:10:22.396Z" }, + { url = "https://files.pythonhosted.org/packages/32/33/8d5398b2da15a15110b2478480ab512609f95b45ead3a105c9a9c76f9980/cryptography-46.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:13e67c4d3fb8b6bc4ef778a7ccdd8df4cd15b4bcc18f4239c8440891a11245cc", size = 4528009, upload-time = "2025-09-17T00:10:24.418Z" }, + { url = "https://files.pythonhosted.org/packages/fd/1c/4012edad2a8977ab386c36b6e21f5065974d37afa3eade83a9968cba4855/cryptography-46.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:15b5fd9358803b0d1cc42505a18d8bca81dabb35b5cfbfea1505092e13a9d96d", size = 4248902, upload-time = "2025-09-17T00:10:26.255Z" }, + { url = "https://files.pythonhosted.org/packages/58/a3/257cd5ae677302de8fa066fca9de37128f6729d1e63c04dd6a15555dd450/cryptography-46.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:e34da95e29daf8a71cb2841fd55df0511539a6cdf33e6f77c1e95e44006b9b46", size = 4527150, upload-time = "2025-09-17T00:10:28.28Z" }, + { url = "https://files.pythonhosted.org/packages/6a/cd/fe6b65e1117ec7631f6be8951d3db076bac3e1b096e3e12710ed071ffc3c/cryptography-46.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:34f04b7311174469ab3ac2647469743720f8b6c8b046f238e5cb27905695eb2a", size = 3448210, upload-time = "2025-09-17T00:10:30.145Z" }, ] [[package]] @@ -1085,6 +1145,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ee/45/b82e3c16be2182bff01179db177fe144d58b5dc787a7d4492c6ed8b9317f/frozenlist-1.7.0-py3-none-any.whl", hash = "sha256:9a5af342e34f7e97caf8c995864c7a396418ae2859cc6fdf1b1073020d516a7e", size = 13106, upload-time = "2025-06-09T23:02:34.204Z" }, ] +[[package]] +name = "fsspec" +version = "2025.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/e0/bab50af11c2d75c9c4a2a26a5254573c0bd97cea152254401510950486fa/fsspec-2025.9.0.tar.gz", hash = "sha256:19fd429483d25d28b65ec68f9f4adc16c17ea2c7c7bf54ec61360d478fb19c19", size = 304847, upload-time = "2025-09-02T19:10:49.215Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/71/70db47e4f6ce3e5c37a607355f80da8860a33226be640226ac52cb05ef2e/fsspec-2025.9.0-py3-none-any.whl", hash = "sha256:530dc2a2af60a414a832059574df4a6e10cce927f6f4a78209390fe38955cfb7", size = 199289, upload-time = "2025-09-02T19:10:47.708Z" }, +] + [[package]] name = "googleapis-common-protos" version = "1.70.0" @@ -1230,6 +1299,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779, upload-time = "2025-08-23T18:12:17.779Z" }, ] +[[package]] +name = "hf-xet" +version = "1.1.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/74/31/feeddfce1748c4a233ec1aa5b7396161c07ae1aa9b7bdbc9a72c3c7dd768/hf_xet-1.1.10.tar.gz", hash = "sha256:408aef343800a2102374a883f283ff29068055c111f003ff840733d3b715bb97", size = 487910, upload-time = "2025-09-12T20:10:27.12Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/a2/343e6d05de96908366bdc0081f2d8607d61200be2ac802769c4284cc65bd/hf_xet-1.1.10-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:686083aca1a6669bc85c21c0563551cbcdaa5cf7876a91f3d074a030b577231d", size = 2761466, upload-time = "2025-09-12T20:10:22.836Z" }, + { url = "https://files.pythonhosted.org/packages/31/f9/6215f948ac8f17566ee27af6430ea72045e0418ce757260248b483f4183b/hf_xet-1.1.10-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:71081925383b66b24eedff3013f8e6bbd41215c3338be4b94ba75fd75b21513b", size = 2623807, upload-time = "2025-09-12T20:10:21.118Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/86397573efefff941e100367bbda0b21496ffcdb34db7ab51912994c32a2/hf_xet-1.1.10-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b6bceb6361c80c1cc42b5a7b4e3efd90e64630bcf11224dcac50ef30a47e435", size = 3186960, upload-time = "2025-09-12T20:10:19.336Z" }, + { url = "https://files.pythonhosted.org/packages/01/a7/0b2e242b918cc30e1f91980f3c4b026ff2eedaf1e2ad96933bca164b2869/hf_xet-1.1.10-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eae7c1fc8a664e54753ffc235e11427ca61f4b0477d757cc4eb9ae374b69f09c", size = 3087167, upload-time = "2025-09-12T20:10:17.255Z" }, + { url = "https://files.pythonhosted.org/packages/4a/25/3e32ab61cc7145b11eee9d745988e2f0f4fafda81b25980eebf97d8cff15/hf_xet-1.1.10-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0a0005fd08f002180f7a12d4e13b22be277725bc23ed0529f8add5c7a6309c06", size = 3248612, upload-time = "2025-09-12T20:10:24.093Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3d/ab7109e607ed321afaa690f557a9ada6d6d164ec852fd6bf9979665dc3d6/hf_xet-1.1.10-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f900481cf6e362a6c549c61ff77468bd59d6dd082f3170a36acfef2eb6a6793f", size = 3353360, upload-time = "2025-09-12T20:10:25.563Z" }, + { url = "https://files.pythonhosted.org/packages/ee/0e/471f0a21db36e71a2f1752767ad77e92d8cde24e974e03d662931b1305ec/hf_xet-1.1.10-cp37-abi3-win_amd64.whl", hash = "sha256:5f54b19cc347c13235ae7ee98b330c26dd65ef1df47e5316ffb1e87713ca7045", size = 2804691, upload-time = "2025-09-12T20:10:28.433Z" }, +] + [[package]] name = "hpack" version = "4.1.0" @@ -1281,6 +1365,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/25/0a/6269e3473b09aed2dab8aa1a600c70f31f00ae1349bee30658f7e358a159/httpx_sse-0.4.1-py3-none-any.whl", hash = "sha256:cba42174344c3a5b06f255ce65b350880f962d99ead85e776f23c6618a377a37", size = 8054, upload-time = "2025-06-24T13:21:04.772Z" }, ] +[[package]] +name = "huggingface-hub" +version = "0.35.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "fsspec", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "hf-xet", marker = "(platform_machine == 'aarch64' and sys_platform == 'darwin') or (platform_machine == 'amd64' and sys_platform == 'darwin') or (platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'x86_64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'win32') or (platform_machine == 'amd64' and sys_platform == 'win32') or (platform_machine == 'arm64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')" }, + { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "pyyaml", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/37/79/d71d40efa058e8c4a075158f8855bc2998037b5ff1c84f249f34435c1df7/huggingface_hub-0.35.0.tar.gz", hash = "sha256:ccadd2a78eef75effff184ad89401413629fabc52cefd76f6bbacb9b1c0676ac", size = 461486, upload-time = "2025-09-16T13:49:33.282Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/85/a18508becfa01f1e4351b5e18651b06d210dbd96debccd48a452acccb901/huggingface_hub-0.35.0-py3-none-any.whl", hash = "sha256:f2e2f693bca9a26530b1c0b9bcd4c1495644dad698e6a0060f90e22e772c31e9", size = 563436, upload-time = "2025-09-16T13:49:30.627Z" }, +] + [[package]] name = "hyperframe" version = "6.1.0" @@ -2019,32 +2122,32 @@ wheels = [ [[package]] name = "opentelemetry-api" -version = "1.36.0" +version = "1.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "importlib-metadata", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/27/d2/c782c88b8afbf961d6972428821c302bd1e9e7bc361352172f0ca31296e2/opentelemetry_api-1.36.0.tar.gz", hash = "sha256:9a72572b9c416d004d492cbc6e61962c0501eaf945ece9b5a0f56597d8348aa0", size = 64780, upload-time = "2025-07-29T15:12:06.02Z" } +sdist = { url = "https://files.pythonhosted.org/packages/63/04/05040d7ce33a907a2a02257e601992f0cdf11c73b33f13c4492bf6c3d6d5/opentelemetry_api-1.37.0.tar.gz", hash = "sha256:540735b120355bd5112738ea53621f8d5edb35ebcd6fe21ada3ab1c61d1cd9a7", size = 64923, upload-time = "2025-09-11T10:29:01.662Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/ee/6b08dde0a022c463b88f55ae81149584b125a42183407dc1045c486cc870/opentelemetry_api-1.36.0-py3-none-any.whl", hash = "sha256:02f20bcacf666e1333b6b1f04e647dc1d5111f86b8e510238fcc56d7762cda8c", size = 65564, upload-time = "2025-07-29T15:11:47.998Z" }, + { url = "https://files.pythonhosted.org/packages/91/48/28ed9e55dcf2f453128df738210a980e09f4e468a456fa3c763dbc8be70a/opentelemetry_api-1.37.0-py3-none-any.whl", hash = "sha256:accf2024d3e89faec14302213bc39550ec0f4095d1cf5ca688e1bfb1c8612f47", size = 65732, upload-time = "2025-09-11T10:28:41.826Z" }, ] [[package]] name = "opentelemetry-exporter-otlp-proto-common" -version = "1.36.0" +version = "1.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-proto", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/34/da/7747e57eb341c59886052d733072bc878424bf20f1d8cf203d508bbece5b/opentelemetry_exporter_otlp_proto_common-1.36.0.tar.gz", hash = "sha256:6c496ccbcbe26b04653cecadd92f73659b814c6e3579af157d8716e5f9f25cbf", size = 20302, upload-time = "2025-07-29T15:12:07.71Z" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/6c/10018cbcc1e6fff23aac67d7fd977c3d692dbe5f9ef9bb4db5c1268726cc/opentelemetry_exporter_otlp_proto_common-1.37.0.tar.gz", hash = "sha256:c87a1bdd9f41fdc408d9cc9367bb53f8d2602829659f2b90be9f9d79d0bfe62c", size = 20430, upload-time = "2025-09-11T10:29:03.605Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/ed/22290dca7db78eb32e0101738366b5bbda00d0407f00feffb9bf8c3fdf87/opentelemetry_exporter_otlp_proto_common-1.36.0-py3-none-any.whl", hash = "sha256:0fc002a6ed63eac235ada9aa7056e5492e9a71728214a61745f6ad04b923f840", size = 18349, upload-time = "2025-07-29T15:11:51.327Z" }, + { url = "https://files.pythonhosted.org/packages/08/13/b4ef09837409a777f3c0af2a5b4ba9b7af34872bc43609dda0c209e4060d/opentelemetry_exporter_otlp_proto_common-1.37.0-py3-none-any.whl", hash = "sha256:53038428449c559b0c564b8d718df3314da387109c4d36bd1b94c9a641b0292e", size = 18359, upload-time = "2025-09-11T10:28:44.939Z" }, ] [[package]] name = "opentelemetry-exporter-otlp-proto-grpc" -version = "1.36.0" +version = "1.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "googleapis-common-protos", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2055,14 +2158,14 @@ dependencies = [ { name = "opentelemetry-sdk", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/72/6f/6c1b0bdd0446e5532294d1d41bf11fbaea39c8a2423a4cdfe4fe6b708127/opentelemetry_exporter_otlp_proto_grpc-1.36.0.tar.gz", hash = "sha256:b281afbf7036b325b3588b5b6c8bb175069e3978d1bd24071f4a59d04c1e5bbf", size = 23822, upload-time = "2025-07-29T15:12:08.292Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d1/11/4ad0979d0bb13ae5a845214e97c8d42da43980034c30d6f72d8e0ebe580e/opentelemetry_exporter_otlp_proto_grpc-1.37.0.tar.gz", hash = "sha256:f55bcb9fc848ce05ad3dd954058bc7b126624d22c4d9e958da24d8537763bec5", size = 24465, upload-time = "2025-09-11T10:29:04.172Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/67/5f6bd188d66d0fd8e81e681bbf5822e53eb150034e2611dd2b935d3ab61a/opentelemetry_exporter_otlp_proto_grpc-1.36.0-py3-none-any.whl", hash = "sha256:734e841fc6a5d6f30e7be4d8053adb703c70ca80c562ae24e8083a28fadef211", size = 18828, upload-time = "2025-07-29T15:11:52.235Z" }, + { url = "https://files.pythonhosted.org/packages/39/17/46630b74751031a658706bef23ac99cdc2953cd3b2d28ec90590a0766b3e/opentelemetry_exporter_otlp_proto_grpc-1.37.0-py3-none-any.whl", hash = "sha256:aee5104835bf7993b7ddaaf380b6467472abaedb1f1dbfcc54a52a7d781a3890", size = 19305, upload-time = "2025-09-11T10:28:45.776Z" }, ] [[package]] name = "opentelemetry-instrumentation" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2070,14 +2173,14 @@ dependencies = [ { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/12/37/cf17cf28f945a3aca5a038cfbb45ee01317d4f7f3a0e5209920883fe9b08/opentelemetry_instrumentation-0.57b0.tar.gz", hash = "sha256:f2a30135ba77cdea2b0e1df272f4163c154e978f57214795d72f40befd4fcf05", size = 30807, upload-time = "2025-07-29T15:42:44.746Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/36/7c307d9be8ce4ee7beb86d7f1d31027f2a6a89228240405a858d6e4d64f9/opentelemetry_instrumentation-0.58b0.tar.gz", hash = "sha256:df640f3ac715a3e05af145c18f527f4422c6ab6c467e40bd24d2ad75a00cb705", size = 31549, upload-time = "2025-09-11T11:42:14.084Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/6f/f20cd1542959f43fb26a5bf9bb18cd81a1ea0700e8870c8f369bd07f5c65/opentelemetry_instrumentation-0.57b0-py3-none-any.whl", hash = "sha256:9109280f44882e07cec2850db28210b90600ae9110b42824d196de357cbddf7e", size = 32460, upload-time = "2025-07-29T15:41:40.883Z" }, + { url = "https://files.pythonhosted.org/packages/d4/db/5ff1cd6c5ca1d12ecf1b73be16fbb2a8af2114ee46d4b0e6d4b23f4f4db7/opentelemetry_instrumentation-0.58b0-py3-none-any.whl", hash = "sha256:50f97ac03100676c9f7fc28197f8240c7290ca1baa12da8bfbb9a1de4f34cc45", size = 33019, upload-time = "2025-09-11T11:41:00.624Z" }, ] [[package]] name = "opentelemetry-instrumentation-asgi" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "asgiref", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2086,14 +2189,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/97/10/7ba59b586eb099fa0155521b387d857de476687c670096597f618d889323/opentelemetry_instrumentation_asgi-0.57b0.tar.gz", hash = "sha256:a6f880b5d1838f65688fc992c65fbb1d3571f319d370990c32e759d3160e510b", size = 24654, upload-time = "2025-07-29T15:42:48.199Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/e2/03ff707d881d590c7adaed5e9d1979aed7e5e53fc1ed89035e5ed9f304af/opentelemetry_instrumentation_asgi-0.58b0.tar.gz", hash = "sha256:3ccc0c9c1c8c71e8d9da5945c6dcd9c0c8d147839f208536b7042c6dd98e65c9", size = 25116, upload-time = "2025-09-11T11:42:18.437Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/07/ab97dd7e8bc680b479203f7d3b2771b7a097468135a669a38da3208f96cb/opentelemetry_instrumentation_asgi-0.57b0-py3-none-any.whl", hash = "sha256:47debbde6af066a7e8e911f7193730d5e40d62effc1ac2e1119908347790a3ea", size = 16599, upload-time = "2025-07-29T15:41:48.332Z" }, + { url = "https://files.pythonhosted.org/packages/8c/71/a00884c6655387c70070138acbf79a6616ad5d4489680f40708d75b598a7/opentelemetry_instrumentation_asgi-0.58b0-py3-none-any.whl", hash = "sha256:508a6d79e333d648d2afee0e140b6e80eb5d443be183be58e81d9ff88373168a", size = 16798, upload-time = "2025-09-11T11:41:08.105Z" }, ] [[package]] name = "opentelemetry-instrumentation-dbapi" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2101,14 +2204,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/15/dc/5a17b2fb593901ba5257278073b28d0ed31497e56985990c26046e4da2d9/opentelemetry_instrumentation_dbapi-0.57b0.tar.gz", hash = "sha256:7ad9e39c91f6212f118435fd6fab842a1f78b2cbad1167f228c025bba2a8fc2d", size = 14176, upload-time = "2025-07-29T15:42:56.249Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/8b/bf6c72d54f77eb0e4445e3b0415e69b3ea5fa40b9372c586db91ffc59b17/opentelemetry_instrumentation_dbapi-0.58b0.tar.gz", hash = "sha256:34ca7e7bf942d5ebf1ea3838e34154b3900bd00d17115a99b83c4ee280e658ac", size = 14223, upload-time = "2025-09-11T11:42:30.771Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/71/21a7e862dead70267b7c7bd5aa4e0b61fbc9fa9b4be57f4e183766abbad9/opentelemetry_instrumentation_dbapi-0.57b0-py3-none-any.whl", hash = "sha256:c1b110a5e86ec9b52b970460917523f47afa0c73f131e7f03c6a7c1921822dc4", size = 12466, upload-time = "2025-07-29T15:41:59.775Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/bf51a3913da9659d17aa1f44860bcc5d721ddcdcdbfbca80b596139d8811/opentelemetry_instrumentation_dbapi-0.58b0-py3-none-any.whl", hash = "sha256:49283687dfc47f05484d4b186fecca8a96b70e18fd406e34c13eb5f09eabb67c", size = 12522, upload-time = "2025-09-11T11:41:23.665Z" }, ] [[package]] name = "opentelemetry-instrumentation-django" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2117,14 +2220,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5a/88/d88268c37aabbd2bcc54f4f868394316fa6fdfd3b91e011d229617d862d3/opentelemetry_instrumentation_django-0.57b0.tar.gz", hash = "sha256:df4116d2ea2c6bbbbf8853b843deb74d66bd0d573ddd372ec84fd60adaf977c6", size = 25005, upload-time = "2025-07-29T15:42:56.88Z" } +sdist = { url = "https://files.pythonhosted.org/packages/69/e8/6055cb9129a5a80b8814b770b79ce559977ff3b3b11dfd4067566ff25c1d/opentelemetry_instrumentation_django-0.58b0.tar.gz", hash = "sha256:24f45706a9dc3c47b9214ed5422fd0d35a850f3f40b04112a91fc10561cfd3f5", size = 25009, upload-time = "2025-09-11T11:42:31.853Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/97/f0/1d5022f2fe16d50b79d9f1f5b70bd08d0e59819e0f6b237cff82c3dbda0f/opentelemetry_instrumentation_django-0.57b0-py3-none-any.whl", hash = "sha256:3d702d79a9ec0c836ccf733becf34630c6afb3c86c25c330c5b7601debe1e7c5", size = 19597, upload-time = "2025-07-29T15:42:00.657Z" }, + { url = "https://files.pythonhosted.org/packages/83/1a/396e941a7aae4e81793931a60669378c64a147a6dca75344b4c26cc8811b/opentelemetry_instrumentation_django-0.58b0-py3-none-any.whl", hash = "sha256:6e3ada766ce965e9486d193e10cb32749bd51fe1adb5ec6b9310e33fe89fad6d", size = 19596, upload-time = "2025-09-11T11:41:24.806Z" }, ] [[package]] name = "opentelemetry-instrumentation-fastapi" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2133,14 +2236,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/47/a8/7c22a33ff5986523a7f9afcb5f4d749533842c3cc77ef55b46727580edd0/opentelemetry_instrumentation_fastapi-0.57b0.tar.gz", hash = "sha256:73ac22f3c472a8f9cb21d1fbe5a4bf2797690c295fff4a1c040e9b1b1688a105", size = 20277, upload-time = "2025-07-29T15:42:58.68Z" } +sdist = { url = "https://files.pythonhosted.org/packages/64/09/4f8fcab834af6b403e5e2d94bdfb2d0835ba8cd1049bcc156995f47b65fb/opentelemetry_instrumentation_fastapi-0.58b0.tar.gz", hash = "sha256:03da470d694116a0a40f4e76319e42f3ff9efc49abf804b2acc2c07f96661497", size = 24598, upload-time = "2025-09-11T11:42:35.325Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/df/f20fc21c88c7af5311bfefc15fc4e606bab5edb7c193aa8c73c354904c35/opentelemetry_instrumentation_fastapi-0.57b0-py3-none-any.whl", hash = "sha256:61e6402749ffe0bfec582e58155e0d81dd38723cd9bc4562bca1acca80334006", size = 12712, upload-time = "2025-07-29T15:42:03.332Z" }, + { url = "https://files.pythonhosted.org/packages/45/fb/82de06eba54e5cb979274f073065ebc374794853502d342b5155073d1194/opentelemetry_instrumentation_fastapi-0.58b0-py3-none-any.whl", hash = "sha256:d89bfec69c9ffc5d9f3fe58655d6660a66b2bca863b9132712c06edcde68b6fa", size = 13460, upload-time = "2025-09-11T11:41:28.507Z" }, ] [[package]] name = "opentelemetry-instrumentation-flask" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2150,28 +2253,28 @@ dependencies = [ { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5f/98/8a8fa41f624069ac2912141b65bd528fd345d65e14a359c4d896fc3dc291/opentelemetry_instrumentation_flask-0.57b0.tar.gz", hash = "sha256:c5244a40b03664db966d844a32f43c900181431b77929be62a68d4907e86ed25", size = 19381, upload-time = "2025-07-29T15:42:59.38Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/df/68aa2dea7e04401f9ce669e6a7a46cc25eb4bb7a14004bf7d535bb27c122/opentelemetry_instrumentation_flask-0.58b0.tar.gz", hash = "sha256:ea2e06f448cef263c21f86401984906f68a5c766c7359000afb5621ae528d9c5", size = 19420, upload-time = "2025-09-11T11:42:36.212Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/3f/79b6c9a240221f5614a143eab6a0ecacdcb23b93cc35ff2b78234f68804f/opentelemetry_instrumentation_flask-0.57b0-py3-none-any.whl", hash = "sha256:5ecd614f194825725b61ee9ba8e37dcd4d3f9b5d40fef759df8650d6a91b1cb9", size = 14688, upload-time = "2025-07-29T15:42:04.162Z" }, + { url = "https://files.pythonhosted.org/packages/07/7f/88079bc3e4aa188d78692328453f906dca35fa9f286623af13df0b0a1ead/opentelemetry_instrumentation_flask-0.58b0-py3-none-any.whl", hash = "sha256:b0d57ad4db7bd0177ddf8c7ae3adf8bd90e2ebfa2dd30884c6a97c97197e4ac5", size = 14685, upload-time = "2025-09-11T11:41:30.02Z" }, ] [[package]] name = "opentelemetry-instrumentation-psycopg2" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-instrumentation", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-instrumentation-dbapi", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a8/66/f2004cde131663810e62b47bb48b684660632876f120c6b1d400a04ccb06/opentelemetry_instrumentation_psycopg2-0.57b0.tar.gz", hash = "sha256:4e9d05d661c50985f0a5d7f090a7f399d453b467c9912c7611fcef693d15b038", size = 10722, upload-time = "2025-07-29T15:43:05.644Z" } +sdist = { url = "https://files.pythonhosted.org/packages/36/3e/eee2fafdd5c7f141cffc588859659e3e0808872c7f8f28d321921d6cc08d/opentelemetry_instrumentation_psycopg2-0.58b0.tar.gz", hash = "sha256:e08e2336926a920bc01788d7ff08315c7d995bd62bc9588c316ebb46f05ae95c", size = 10735, upload-time = "2025-09-11T11:42:44.424Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/02/40/00f9c1334fb0c9d74c99d37c4a730cbe6dc941eea5fae6f9bc36e5a53d19/opentelemetry_instrumentation_psycopg2-0.57b0-py3-none-any.whl", hash = "sha256:94fdde02b7451c8e85d43b4b9dd13a34fee96ffd43324d1b3567f47d2903b99f", size = 10721, upload-time = "2025-07-29T15:42:15.698Z" }, + { url = "https://files.pythonhosted.org/packages/20/d8/5e92e7e1be63076a23309523c827437ab7e4f77c20fa2077c49aa055cf56/opentelemetry_instrumentation_psycopg2-0.58b0-py3-none-any.whl", hash = "sha256:6afa483f4d1f6d94702082c96e5a0e14bad32195e0d3c10ab5cda92a8f523e36", size = 10732, upload-time = "2025-09-11T11:41:42.118Z" }, ] [[package]] name = "opentelemetry-instrumentation-requests" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2179,14 +2282,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0d/e1/01f5c28a60ffbc4c04946ad35bc8bf16382d333e41afaa042b31c35364b9/opentelemetry_instrumentation_requests-0.57b0.tar.gz", hash = "sha256:193bd3fd1f14737721876fb1952dffc7d43795586118df633a91ecd9057446ff", size = 15182, upload-time = "2025-07-29T15:43:11.812Z" } +sdist = { url = "https://files.pythonhosted.org/packages/36/42/83ee32de763b919779aaa595b60c5a7b9c0a4b33952bbe432c5f6a783085/opentelemetry_instrumentation_requests-0.58b0.tar.gz", hash = "sha256:ae9495e6ff64e27bdb839fce91dbb4be56e325139828e8005f875baf41951a2e", size = 15188, upload-time = "2025-09-11T11:42:51.268Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b5/7d/40144701fa22521e3b3fce23e2f0a5684a9385c90b119b70e7598b3cb607/opentelemetry_instrumentation_requests-0.57b0-py3-none-any.whl", hash = "sha256:66a576ac8080724ddc8a14c39d16bb5f430991bd504fdbea844c7a063f555971", size = 12966, upload-time = "2025-07-29T15:42:24.608Z" }, + { url = "https://files.pythonhosted.org/packages/90/4d/f3476b28ea167d1762134352d01ae9693940a42c78994d9f1b32a4477816/opentelemetry_instrumentation_requests-0.58b0-py3-none-any.whl", hash = "sha256:672a0be0bb5b52bea0c11820b35e27edcf4cd22d34abe4afc59a92a80519f8a8", size = 12966, upload-time = "2025-09-11T11:41:52.67Z" }, ] [[package]] name = "opentelemetry-instrumentation-urllib" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2194,14 +2297,14 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/a5/9d400dd978ac5e81356fe8435ca264e140a7d4cf77a88db43791d62311d5/opentelemetry_instrumentation_urllib-0.57b0.tar.gz", hash = "sha256:657225ceae8bb52b67bd5c26dcb8a33f0efb041f1baea4c59dbd1adbc63a4162", size = 13929, upload-time = "2025-07-29T15:43:16.498Z" } +sdist = { url = "https://files.pythonhosted.org/packages/84/94/48171907cb9ced5bdc5be18f8cc8a8234bb2ec695f20c69f1330b336f2fb/opentelemetry_instrumentation_urllib-0.58b0.tar.gz", hash = "sha256:071e5a28a1c4198cfa33937484f4b0b1068aab26d75e71e55f598a717f268d0a", size = 13932, upload-time = "2025-09-11T11:42:58.798Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/47/3c9535a68b9dd125eb6a25c086984e5cee7285e4f36bfa37eeb40e95d2b5/opentelemetry_instrumentation_urllib-0.57b0-py3-none-any.whl", hash = "sha256:bb3a01172109a6f56bfcc38ea83b9d4a61c4c2cac6b9a190e757063daadf545c", size = 12671, upload-time = "2025-07-29T15:42:34.561Z" }, + { url = "https://files.pythonhosted.org/packages/57/66/37edce21a14b6a983577d7aea95fee3581e80f9b4a272f514726e5041104/opentelemetry_instrumentation_urllib-0.58b0-py3-none-any.whl", hash = "sha256:63ad8a304a299bcb39224ecedc718a391404c8f2d4cc5755edfb5e49904e7b27", size = 12674, upload-time = "2025-09-11T11:42:02.776Z" }, ] [[package]] name = "opentelemetry-instrumentation-urllib3" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2210,14 +2313,14 @@ dependencies = [ { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9a/2d/c241e9716c94704dbddf64e2c7367b57642425455befdbc622936bec78e9/opentelemetry_instrumentation_urllib3-0.57b0.tar.gz", hash = "sha256:f49d8c3d1d81ae56304a08b14a7f564d250733ed75cd2210ccef815b5af2eea1", size = 15790, upload-time = "2025-07-29T15:43:17.05Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9f/e7/affaeadd974587c6eaab1c8af2dfba776dcc083493c97cb193173570d335/opentelemetry_instrumentation_urllib3-0.58b0.tar.gz", hash = "sha256:978b8e3daa076437b1f7ed7509d8156108aee0679556fd355e532c4065dd7635", size = 15791, upload-time = "2025-09-11T11:42:59.582Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/06/0e/a5467ab57d815caa58cbabb3a7f3906c3718c599221ac770482d13187306/opentelemetry_instrumentation_urllib3-0.57b0-py3-none-any.whl", hash = "sha256:337ecac6df3ff92026b51c64df7dd4a3fff52f2dc96036ea9371670243bf83c6", size = 13186, upload-time = "2025-07-29T15:42:35.775Z" }, + { url = "https://files.pythonhosted.org/packages/1a/5f/d960be00ec15a722f2bfff9d226b320cc6c4191b737c98b937541fdecf83/opentelemetry_instrumentation_urllib3-0.58b0-py3-none-any.whl", hash = "sha256:9e698785afe311edfab772152cb4851f1aaffde5110bb83e4e45d8c4e97277ee", size = 13188, upload-time = "2025-09-11T11:42:04.183Z" }, ] [[package]] name = "opentelemetry-instrumentation-wsgi" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2225,21 +2328,21 @@ dependencies = [ { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-util-http", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f8/3f/d1ab49d68f2f6ebbe3c2fa5ff609ee5603a9cc68915203c454afb3a38d5b/opentelemetry_instrumentation_wsgi-0.57b0.tar.gz", hash = "sha256:d7e16b3b87930c30fc4c1bbc8b58c5dd6eefade493a3a5e7343bc24d572bc5b7", size = 18376, upload-time = "2025-07-29T15:43:17.683Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/76/c33bb3f219dc2266f98b8f927e913e93b31e94af7aa6430a9a9f167f9ab2/opentelemetry_instrumentation_wsgi-0.58b0.tar.gz", hash = "sha256:0ea27d44c83b48e6b182a904c801ca62b2999642647f32ef33c8a9c8bbf6a245", size = 18377, upload-time = "2025-09-11T11:43:02.589Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1f/0c/7760f9e14f4f8128e4880b4fd5f232ef4eb00cb29ee560c972dbf7801369/opentelemetry_instrumentation_wsgi-0.57b0-py3-none-any.whl", hash = "sha256:b9cf0c6e61489f7503fc17ef04d169bd214e7a825650ee492f5d2b4d73b17b54", size = 14450, upload-time = "2025-07-29T15:42:37.351Z" }, + { url = "https://files.pythonhosted.org/packages/81/05/a168ba97831823e170937b4f1a0f95657c8bd9cc573c81629f464c3cc32b/opentelemetry_instrumentation_wsgi-0.58b0-py3-none-any.whl", hash = "sha256:cef5bdf1cb7a5162fdb1c1a2f95e4a08e02b1ca67ce828a1efdf81e9f23273b7", size = 14449, upload-time = "2025-09-11T11:42:05.323Z" }, ] [[package]] name = "opentelemetry-proto" -version = "1.36.0" +version = "1.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fd/02/f6556142301d136e3b7e95ab8ea6a5d9dc28d879a99f3dd673b5f97dca06/opentelemetry_proto-1.36.0.tar.gz", hash = "sha256:0f10b3c72f74c91e0764a5ec88fd8f1c368ea5d9c64639fb455e2854ef87dd2f", size = 46152, upload-time = "2025-07-29T15:12:15.717Z" } +sdist = { url = "https://files.pythonhosted.org/packages/dd/ea/a75f36b463a36f3c5a10c0b5292c58b31dbdde74f6f905d3d0ab2313987b/opentelemetry_proto-1.37.0.tar.gz", hash = "sha256:30f5c494faf66f77faeaefa35ed4443c5edb3b0aa46dad073ed7210e1a789538", size = 46151, upload-time = "2025-09-11T10:29:11.04Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/57/3361e06136225be8180e879199caea520f38026f8071366241ac458beb8d/opentelemetry_proto-1.36.0-py3-none-any.whl", hash = "sha256:151b3bf73a09f94afc658497cf77d45a565606f62ce0c17acb08cd9937ca206e", size = 72537, upload-time = "2025-07-29T15:12:02.243Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/f89ea66c59bd7687e218361826c969443c4fa15dfe89733f3bf1e2a9e971/opentelemetry_proto-1.37.0-py3-none-any.whl", hash = "sha256:8ed8c066ae8828bbf0c39229979bdf583a126981142378a9cbe9d6fd5701c6e2", size = 72534, upload-time = "2025-09-11T10:28:56.831Z" }, ] [[package]] @@ -2256,29 +2359,29 @@ wheels = [ [[package]] name = "opentelemetry-sdk" -version = "1.36.0" +version = "1.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/4c/85/8567a966b85a2d3f971c4d42f781c305b2b91c043724fa08fd37d158e9dc/opentelemetry_sdk-1.36.0.tar.gz", hash = "sha256:19c8c81599f51b71670661ff7495c905d8fdf6976e41622d5245b791b06fa581", size = 162557, upload-time = "2025-07-29T15:12:16.76Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/62/2e0ca80d7fe94f0b193135375da92c640d15fe81f636658d2acf373086bc/opentelemetry_sdk-1.37.0.tar.gz", hash = "sha256:cc8e089c10953ded765b5ab5669b198bbe0af1b3f89f1007d19acd32dc46dda5", size = 170404, upload-time = "2025-09-11T10:29:11.779Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/59/7bed362ad1137ba5886dac8439e84cd2df6d087be7c09574ece47ae9b22c/opentelemetry_sdk-1.36.0-py3-none-any.whl", hash = "sha256:19fe048b42e98c5c1ffe85b569b7073576ad4ce0bcb6e9b4c6a39e890a6c45fb", size = 119995, upload-time = "2025-07-29T15:12:03.181Z" }, + { url = "https://files.pythonhosted.org/packages/9f/62/9f4ad6a54126fb00f7ed4bb5034964c6e4f00fcd5a905e115bd22707e20d/opentelemetry_sdk-1.37.0-py3-none-any.whl", hash = "sha256:8f3c3c22063e52475c5dbced7209495c2c16723d016d39287dfc215d1771257c", size = 131941, upload-time = "2025-09-11T10:28:57.83Z" }, ] [[package]] name = "opentelemetry-semantic-conventions" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7e/31/67dfa252ee88476a29200b0255bda8dfc2cf07b56ad66dc9a6221f7dc787/opentelemetry_semantic_conventions-0.57b0.tar.gz", hash = "sha256:609a4a79c7891b4620d64c7aac6898f872d790d75f22019913a660756f27ff32", size = 124225, upload-time = "2025-07-29T15:12:17.873Z" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/1b/90701d91e6300d9f2fb352153fb1721ed99ed1f6ea14fa992c756016e63a/opentelemetry_semantic_conventions-0.58b0.tar.gz", hash = "sha256:6bd46f51264279c433755767bb44ad00f1c9e2367e1b42af563372c5a6fa0c25", size = 129867, upload-time = "2025-09-11T10:29:12.597Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/05/75/7d591371c6c39c73de5ce5da5a2cc7b72d1d1cd3f8f4638f553c01c37b11/opentelemetry_semantic_conventions-0.57b0-py3-none-any.whl", hash = "sha256:757f7e76293294f124c827e514c2a3144f191ef175b069ce8d1211e1e38e9e78", size = 201627, upload-time = "2025-07-29T15:12:04.174Z" }, + { url = "https://files.pythonhosted.org/packages/07/90/68152b7465f50285d3ce2481b3aec2f82822e3f52e5152eeeaf516bab841/opentelemetry_semantic_conventions-0.58b0-py3-none-any.whl", hash = "sha256:5564905ab1458b96684db1340232729fce3b5375a06e140e8904c78e4f815b28", size = 207954, upload-time = "2025-09-11T10:28:59.218Z" }, ] [[package]] @@ -2292,11 +2395,88 @@ wheels = [ [[package]] name = "opentelemetry-util-http" -version = "0.57b0" +version = "0.58b0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9b/1b/6229c45445e08e798fa825f5376f6d6a4211d29052a4088eed6d577fa653/opentelemetry_util_http-0.57b0.tar.gz", hash = "sha256:f7417595ead0eb42ed1863ec9b2f839fc740368cd7bbbfc1d0a47bc1ab0aba11", size = 9405, upload-time = "2025-07-29T15:43:19.916Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c6/5f/02f31530faf50ef8a41ab34901c05cbbf8e9d76963ba2fb852b0b4065f4e/opentelemetry_util_http-0.58b0.tar.gz", hash = "sha256:de0154896c3472c6599311c83e0ecee856c4da1b17808d39fdc5cce5312e4d89", size = 9411, upload-time = "2025-09-11T11:43:05.602Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/a6/b98d508d189b9c208f5978d0906141747d7e6df7c7cafec03657ed1ed559/opentelemetry_util_http-0.57b0-py3-none-any.whl", hash = "sha256:e54c0df5543951e471c3d694f85474977cd5765a3b7654398c83bab3d2ffb8e9", size = 7643, upload-time = "2025-07-29T15:42:41.744Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a3/0a1430c42c6d34d8372a16c104e7408028f0c30270d8f3eb6cccf2e82934/opentelemetry_util_http-0.58b0-py3-none-any.whl", hash = "sha256:6c6b86762ed43025fbd593dc5f700ba0aa3e09711aedc36fd48a13b23d8cb1e7", size = 7652, upload-time = "2025-09-11T11:42:09.682Z" }, +] + +[[package]] +name = "orjson" +version = "3.11.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/4d/8df5f83256a809c22c4d6792ce8d43bb503be0fb7a8e4da9025754b09658/orjson-3.11.3.tar.gz", hash = "sha256:1c0603b1d2ffcd43a411d64797a19556ef76958aef1c182f22dc30860152a98a", size = 5482394, upload-time = "2025-08-26T17:46:43.171Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/64/4a3cef001c6cd9c64256348d4c13a7b09b857e3e1cbb5185917df67d8ced/orjson-3.11.3-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:29cb1f1b008d936803e2da3d7cba726fc47232c45df531b29edf0b232dd737e7", size = 238600, upload-time = "2025-08-26T17:44:36.875Z" }, + { url = "https://files.pythonhosted.org/packages/10/ce/0c8c87f54f79d051485903dc46226c4d3220b691a151769156054df4562b/orjson-3.11.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97dceed87ed9139884a55db8722428e27bd8452817fbf1869c58b49fecab1120", size = 123526, upload-time = "2025-08-26T17:44:39.574Z" }, + { url = "https://files.pythonhosted.org/packages/ef/d0/249497e861f2d438f45b3ab7b7b361484237414945169aa285608f9f7019/orjson-3.11.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:58533f9e8266cb0ac298e259ed7b4d42ed3fa0b78ce76860626164de49e0d467", size = 128075, upload-time = "2025-08-26T17:44:40.672Z" }, + { url = "https://files.pythonhosted.org/packages/e5/64/00485702f640a0fd56144042a1ea196469f4a3ae93681871564bf74fa996/orjson-3.11.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c212cfdd90512fe722fa9bd620de4d46cda691415be86b2e02243242ae81873", size = 130483, upload-time = "2025-08-26T17:44:41.788Z" }, + { url = "https://files.pythonhosted.org/packages/64/81/110d68dba3909171bf3f05619ad0cf187b430e64045ae4e0aa7ccfe25b15/orjson-3.11.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff835b5d3e67d9207343effb03760c00335f8b5285bfceefd4dc967b0e48f6a", size = 132539, upload-time = "2025-08-26T17:44:43.12Z" }, + { url = "https://files.pythonhosted.org/packages/79/92/dba25c22b0ddfafa1e6516a780a00abac28d49f49e7202eb433a53c3e94e/orjson-3.11.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f5aa4682912a450c2db89cbd92d356fef47e115dffba07992555542f344d301b", size = 135390, upload-time = "2025-08-26T17:44:44.199Z" }, + { url = "https://files.pythonhosted.org/packages/44/1d/ca2230fd55edbd87b58a43a19032d63a4b180389a97520cc62c535b726f9/orjson-3.11.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7d18dd34ea2e860553a579df02041845dee0af8985dff7f8661306f95504ddf", size = 132966, upload-time = "2025-08-26T17:44:45.719Z" }, + { url = "https://files.pythonhosted.org/packages/6e/b9/96bbc8ed3e47e52b487d504bd6861798977445fbc410da6e87e302dc632d/orjson-3.11.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d8b11701bc43be92ea42bd454910437b355dfb63696c06fe953ffb40b5f763b4", size = 131349, upload-time = "2025-08-26T17:44:46.862Z" }, + { url = "https://files.pythonhosted.org/packages/c4/3c/418fbd93d94b0df71cddf96b7fe5894d64a5d890b453ac365120daec30f7/orjson-3.11.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:90368277087d4af32d38bd55f9da2ff466d25325bf6167c8f382d8ee40cb2bbc", size = 404087, upload-time = "2025-08-26T17:44:48.079Z" }, + { url = "https://files.pythonhosted.org/packages/5b/a9/2bfd58817d736c2f63608dec0c34857339d423eeed30099b126562822191/orjson-3.11.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fd7ff459fb393358d3a155d25b275c60b07a2c83dcd7ea962b1923f5a1134569", size = 146067, upload-time = "2025-08-26T17:44:49.302Z" }, + { url = "https://files.pythonhosted.org/packages/33/ba/29023771f334096f564e48d82ed855a0ed3320389d6748a9c949e25be734/orjson-3.11.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f8d902867b699bcd09c176a280b1acdab57f924489033e53d0afe79817da37e6", size = 135506, upload-time = "2025-08-26T17:44:50.558Z" }, + { url = "https://files.pythonhosted.org/packages/39/62/b5a1eca83f54cb3aa11a9645b8a22f08d97dbd13f27f83aae7c6666a0a05/orjson-3.11.3-cp310-cp310-win32.whl", hash = "sha256:bb93562146120bb51e6b154962d3dadc678ed0fce96513fa6bc06599bb6f6edc", size = 136352, upload-time = "2025-08-26T17:44:51.698Z" }, + { url = "https://files.pythonhosted.org/packages/e3/c0/7ebfaa327d9a9ed982adc0d9420dbce9a3fec45b60ab32c6308f731333fa/orjson-3.11.3-cp310-cp310-win_amd64.whl", hash = "sha256:976c6f1975032cc327161c65d4194c549f2589d88b105a5e3499429a54479770", size = 131539, upload-time = "2025-08-26T17:44:52.974Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/360674cd817faef32e49276187922a946468579fcaf37afdfb6c07046e92/orjson-3.11.3-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9d2ae0cc6aeb669633e0124531f342a17d8e97ea999e42f12a5ad4adaa304c5f", size = 238238, upload-time = "2025-08-26T17:44:54.214Z" }, + { url = "https://files.pythonhosted.org/packages/05/3d/5fa9ea4b34c1a13be7d9046ba98d06e6feb1d8853718992954ab59d16625/orjson-3.11.3-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:ba21dbb2493e9c653eaffdc38819b004b7b1b246fb77bfc93dc016fe664eac91", size = 127713, upload-time = "2025-08-26T17:44:55.596Z" }, + { url = "https://files.pythonhosted.org/packages/e5/5f/e18367823925e00b1feec867ff5f040055892fc474bf5f7875649ecfa586/orjson-3.11.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00f1a271e56d511d1569937c0447d7dce5a99a33ea0dec76673706360a051904", size = 123241, upload-time = "2025-08-26T17:44:57.185Z" }, + { url = "https://files.pythonhosted.org/packages/0f/bd/3c66b91c4564759cf9f473251ac1650e446c7ba92a7c0f9f56ed54f9f0e6/orjson-3.11.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b67e71e47caa6680d1b6f075a396d04fa6ca8ca09aafb428731da9b3ea32a5a6", size = 127895, upload-time = "2025-08-26T17:44:58.349Z" }, + { url = "https://files.pythonhosted.org/packages/82/b5/dc8dcd609db4766e2967a85f63296c59d4722b39503e5b0bf7fd340d387f/orjson-3.11.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d7d012ebddffcce8c85734a6d9e5f08180cd3857c5f5a3ac70185b43775d043d", size = 130303, upload-time = "2025-08-26T17:44:59.491Z" }, + { url = "https://files.pythonhosted.org/packages/48/c2/d58ec5fd1270b2aa44c862171891adc2e1241bd7dab26c8f46eb97c6c6f1/orjson-3.11.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd759f75d6b8d1b62012b7f5ef9461d03c804f94d539a5515b454ba3a6588038", size = 132366, upload-time = "2025-08-26T17:45:00.654Z" }, + { url = "https://files.pythonhosted.org/packages/73/87/0ef7e22eb8dd1ef940bfe3b9e441db519e692d62ed1aae365406a16d23d0/orjson-3.11.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6890ace0809627b0dff19cfad92d69d0fa3f089d3e359a2a532507bb6ba34efb", size = 135180, upload-time = "2025-08-26T17:45:02.424Z" }, + { url = "https://files.pythonhosted.org/packages/bb/6a/e5bf7b70883f374710ad74faf99bacfc4b5b5a7797c1d5e130350e0e28a3/orjson-3.11.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9d4a5e041ae435b815e568537755773d05dac031fee6a57b4ba70897a44d9d2", size = 132741, upload-time = "2025-08-26T17:45:03.663Z" }, + { url = "https://files.pythonhosted.org/packages/bd/0c/4577fd860b6386ffaa56440e792af01c7882b56d2766f55384b5b0e9d39b/orjson-3.11.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2d68bf97a771836687107abfca089743885fb664b90138d8761cce61d5625d55", size = 131104, upload-time = "2025-08-26T17:45:04.939Z" }, + { url = "https://files.pythonhosted.org/packages/66/4b/83e92b2d67e86d1c33f2ea9411742a714a26de63641b082bdbf3d8e481af/orjson-3.11.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:bfc27516ec46f4520b18ef645864cee168d2a027dbf32c5537cb1f3e3c22dac1", size = 403887, upload-time = "2025-08-26T17:45:06.228Z" }, + { url = "https://files.pythonhosted.org/packages/6d/e5/9eea6a14e9b5ceb4a271a1fd2e1dec5f2f686755c0fab6673dc6ff3433f4/orjson-3.11.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f66b001332a017d7945e177e282a40b6997056394e3ed7ddb41fb1813b83e824", size = 145855, upload-time = "2025-08-26T17:45:08.338Z" }, + { url = "https://files.pythonhosted.org/packages/45/78/8d4f5ad0c80ba9bf8ac4d0fc71f93a7d0dc0844989e645e2074af376c307/orjson-3.11.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:212e67806525d2561efbfe9e799633b17eb668b8964abed6b5319b2f1cfbae1f", size = 135361, upload-time = "2025-08-26T17:45:09.625Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5f/16386970370178d7a9b438517ea3d704efcf163d286422bae3b37b88dbb5/orjson-3.11.3-cp311-cp311-win32.whl", hash = "sha256:6e8e0c3b85575a32f2ffa59de455f85ce002b8bdc0662d6b9c2ed6d80ab5d204", size = 136190, upload-time = "2025-08-26T17:45:10.962Z" }, + { url = "https://files.pythonhosted.org/packages/09/60/db16c6f7a41dd8ac9fb651f66701ff2aeb499ad9ebc15853a26c7c152448/orjson-3.11.3-cp311-cp311-win_amd64.whl", hash = "sha256:6be2f1b5d3dc99a5ce5ce162fc741c22ba9f3443d3dd586e6a1211b7bc87bc7b", size = 131389, upload-time = "2025-08-26T17:45:12.285Z" }, + { url = "https://files.pythonhosted.org/packages/3e/2a/bb811ad336667041dea9b8565c7c9faf2f59b47eb5ab680315eea612ef2e/orjson-3.11.3-cp311-cp311-win_arm64.whl", hash = "sha256:fafb1a99d740523d964b15c8db4eabbfc86ff29f84898262bf6e3e4c9e97e43e", size = 126120, upload-time = "2025-08-26T17:45:13.515Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b0/a7edab2a00cdcb2688e1c943401cb3236323e7bfd2839815c6131a3742f4/orjson-3.11.3-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:8c752089db84333e36d754c4baf19c0e1437012242048439c7e80eb0e6426e3b", size = 238259, upload-time = "2025-08-26T17:45:15.093Z" }, + { url = "https://files.pythonhosted.org/packages/e1/c6/ff4865a9cc398a07a83342713b5932e4dc3cb4bf4bc04e8f83dedfc0d736/orjson-3.11.3-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:9b8761b6cf04a856eb544acdd82fc594b978f12ac3602d6374a7edb9d86fd2c2", size = 127633, upload-time = "2025-08-26T17:45:16.417Z" }, + { url = "https://files.pythonhosted.org/packages/6e/e6/e00bea2d9472f44fe8794f523e548ce0ad51eb9693cf538a753a27b8bda4/orjson-3.11.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b13974dc8ac6ba22feaa867fc19135a3e01a134b4f7c9c28162fed4d615008a", size = 123061, upload-time = "2025-08-26T17:45:17.673Z" }, + { url = "https://files.pythonhosted.org/packages/54/31/9fbb78b8e1eb3ac605467cb846e1c08d0588506028b37f4ee21f978a51d4/orjson-3.11.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f83abab5bacb76d9c821fd5c07728ff224ed0e52d7a71b7b3de822f3df04e15c", size = 127956, upload-time = "2025-08-26T17:45:19.172Z" }, + { url = "https://files.pythonhosted.org/packages/36/88/b0604c22af1eed9f98d709a96302006915cfd724a7ebd27d6dd11c22d80b/orjson-3.11.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e6fbaf48a744b94091a56c62897b27c31ee2da93d826aa5b207131a1e13d4064", size = 130790, upload-time = "2025-08-26T17:45:20.586Z" }, + { url = "https://files.pythonhosted.org/packages/0e/9d/1c1238ae9fffbfed51ba1e507731b3faaf6b846126a47e9649222b0fd06f/orjson-3.11.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc779b4f4bba2847d0d2940081a7b6f7b5877e05408ffbb74fa1faf4a136c424", size = 132385, upload-time = "2025-08-26T17:45:22.036Z" }, + { url = "https://files.pythonhosted.org/packages/a3/b5/c06f1b090a1c875f337e21dd71943bc9d84087f7cdf8c6e9086902c34e42/orjson-3.11.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd4b909ce4c50faa2192da6bb684d9848d4510b736b0611b6ab4020ea6fd2d23", size = 135305, upload-time = "2025-08-26T17:45:23.4Z" }, + { url = "https://files.pythonhosted.org/packages/a0/26/5f028c7d81ad2ebbf84414ba6d6c9cac03f22f5cd0d01eb40fb2d6a06b07/orjson-3.11.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:524b765ad888dc5518bbce12c77c2e83dee1ed6b0992c1790cc5fb49bb4b6667", size = 132875, upload-time = "2025-08-26T17:45:25.182Z" }, + { url = "https://files.pythonhosted.org/packages/fe/d4/b8df70d9cfb56e385bf39b4e915298f9ae6c61454c8154a0f5fd7efcd42e/orjson-3.11.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:84fd82870b97ae3cdcea9d8746e592b6d40e1e4d4527835fc520c588d2ded04f", size = 130940, upload-time = "2025-08-26T17:45:27.209Z" }, + { url = "https://files.pythonhosted.org/packages/da/5e/afe6a052ebc1a4741c792dd96e9f65bf3939d2094e8b356503b68d48f9f5/orjson-3.11.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fbecb9709111be913ae6879b07bafd4b0785b44c1eb5cac8ac76da048b3885a1", size = 403852, upload-time = "2025-08-26T17:45:28.478Z" }, + { url = "https://files.pythonhosted.org/packages/f8/90/7bbabafeb2ce65915e9247f14a56b29c9334003536009ef5b122783fe67e/orjson-3.11.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9dba358d55aee552bd868de348f4736ca5a4086d9a62e2bfbbeeb5629fe8b0cc", size = 146293, upload-time = "2025-08-26T17:45:29.86Z" }, + { url = "https://files.pythonhosted.org/packages/27/b3/2d703946447da8b093350570644a663df69448c9d9330e5f1d9cce997f20/orjson-3.11.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eabcf2e84f1d7105f84580e03012270c7e97ecb1fb1618bda395061b2a84a049", size = 135470, upload-time = "2025-08-26T17:45:31.243Z" }, + { url = "https://files.pythonhosted.org/packages/38/70/b14dcfae7aff0e379b0119c8a812f8396678919c431efccc8e8a0263e4d9/orjson-3.11.3-cp312-cp312-win32.whl", hash = "sha256:3782d2c60b8116772aea8d9b7905221437fdf53e7277282e8d8b07c220f96cca", size = 136248, upload-time = "2025-08-26T17:45:32.567Z" }, + { url = "https://files.pythonhosted.org/packages/35/b8/9e3127d65de7fff243f7f3e53f59a531bf6bb295ebe5db024c2503cc0726/orjson-3.11.3-cp312-cp312-win_amd64.whl", hash = "sha256:79b44319268af2eaa3e315b92298de9a0067ade6e6003ddaef72f8e0bedb94f1", size = 131437, upload-time = "2025-08-26T17:45:34.949Z" }, + { url = "https://files.pythonhosted.org/packages/51/92/a946e737d4d8a7fd84a606aba96220043dcc7d6988b9e7551f7f6d5ba5ad/orjson-3.11.3-cp312-cp312-win_arm64.whl", hash = "sha256:0e92a4e83341ef79d835ca21b8bd13e27c859e4e9e4d7b63defc6e58462a3710", size = 125978, upload-time = "2025-08-26T17:45:36.422Z" }, + { url = "https://files.pythonhosted.org/packages/fc/79/8932b27293ad35919571f77cb3693b5906cf14f206ef17546052a241fdf6/orjson-3.11.3-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:af40c6612fd2a4b00de648aa26d18186cd1322330bd3a3cc52f87c699e995810", size = 238127, upload-time = "2025-08-26T17:45:38.146Z" }, + { url = "https://files.pythonhosted.org/packages/1c/82/cb93cd8cf132cd7643b30b6c5a56a26c4e780c7a145db6f83de977b540ce/orjson-3.11.3-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:9f1587f26c235894c09e8b5b7636a38091a9e6e7fe4531937534749c04face43", size = 127494, upload-time = "2025-08-26T17:45:39.57Z" }, + { url = "https://files.pythonhosted.org/packages/a4/b8/2d9eb181a9b6bb71463a78882bcac1027fd29cf62c38a40cc02fc11d3495/orjson-3.11.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:61dcdad16da5bb486d7227a37a2e789c429397793a6955227cedbd7252eb5a27", size = 123017, upload-time = "2025-08-26T17:45:40.876Z" }, + { url = "https://files.pythonhosted.org/packages/b4/14/a0e971e72d03b509190232356d54c0f34507a05050bd026b8db2bf2c192c/orjson-3.11.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:11c6d71478e2cbea0a709e8a06365fa63da81da6498a53e4c4f065881d21ae8f", size = 127898, upload-time = "2025-08-26T17:45:42.188Z" }, + { url = "https://files.pythonhosted.org/packages/8e/af/dc74536722b03d65e17042cc30ae586161093e5b1f29bccda24765a6ae47/orjson-3.11.3-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff94112e0098470b665cb0ed06efb187154b63649403b8d5e9aedeb482b4548c", size = 130742, upload-time = "2025-08-26T17:45:43.511Z" }, + { url = "https://files.pythonhosted.org/packages/62/e6/7a3b63b6677bce089fe939353cda24a7679825c43a24e49f757805fc0d8a/orjson-3.11.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae8b756575aaa2a855a75192f356bbda11a89169830e1439cfb1a3e1a6dde7be", size = 132377, upload-time = "2025-08-26T17:45:45.525Z" }, + { url = "https://files.pythonhosted.org/packages/fc/cd/ce2ab93e2e7eaf518f0fd15e3068b8c43216c8a44ed82ac2b79ce5cef72d/orjson-3.11.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c9416cc19a349c167ef76135b2fe40d03cea93680428efee8771f3e9fb66079d", size = 135313, upload-time = "2025-08-26T17:45:46.821Z" }, + { url = "https://files.pythonhosted.org/packages/d0/b4/f98355eff0bd1a38454209bbc73372ce351ba29933cb3e2eba16c04b9448/orjson-3.11.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b822caf5b9752bc6f246eb08124c3d12bf2175b66ab74bac2ef3bbf9221ce1b2", size = 132908, upload-time = "2025-08-26T17:45:48.126Z" }, + { url = "https://files.pythonhosted.org/packages/eb/92/8f5182d7bc2a1bed46ed960b61a39af8389f0ad476120cd99e67182bfb6d/orjson-3.11.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:414f71e3bdd5573893bf5ecdf35c32b213ed20aa15536fe2f588f946c318824f", size = 130905, upload-time = "2025-08-26T17:45:49.414Z" }, + { url = "https://files.pythonhosted.org/packages/1a/60/c41ca753ce9ffe3d0f67b9b4c093bdd6e5fdb1bc53064f992f66bb99954d/orjson-3.11.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:828e3149ad8815dc14468f36ab2a4b819237c155ee1370341b91ea4c8672d2ee", size = 403812, upload-time = "2025-08-26T17:45:51.085Z" }, + { url = "https://files.pythonhosted.org/packages/dd/13/e4a4f16d71ce1868860db59092e78782c67082a8f1dc06a3788aef2b41bc/orjson-3.11.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ac9e05f25627ffc714c21f8dfe3a579445a5c392a9c8ae7ba1d0e9fb5333f56e", size = 146277, upload-time = "2025-08-26T17:45:52.851Z" }, + { url = "https://files.pythonhosted.org/packages/8d/8b/bafb7f0afef9344754a3a0597a12442f1b85a048b82108ef2c956f53babd/orjson-3.11.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e44fbe4000bd321d9f3b648ae46e0196d21577cf66ae684a96ff90b1f7c93633", size = 135418, upload-time = "2025-08-26T17:45:54.806Z" }, + { url = "https://files.pythonhosted.org/packages/60/d4/bae8e4f26afb2c23bea69d2f6d566132584d1c3a5fe89ee8c17b718cab67/orjson-3.11.3-cp313-cp313-win32.whl", hash = "sha256:2039b7847ba3eec1f5886e75e6763a16e18c68a63efc4b029ddf994821e2e66b", size = 136216, upload-time = "2025-08-26T17:45:57.182Z" }, + { url = "https://files.pythonhosted.org/packages/88/76/224985d9f127e121c8cad882cea55f0ebe39f97925de040b75ccd4b33999/orjson-3.11.3-cp313-cp313-win_amd64.whl", hash = "sha256:29be5ac4164aa8bdcba5fa0700a3c9c316b411d8ed9d39ef8a882541bd452fae", size = 131362, upload-time = "2025-08-26T17:45:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cf/0dce7a0be94bd36d1346be5067ed65ded6adb795fdbe3abd234c8d576d01/orjson-3.11.3-cp313-cp313-win_arm64.whl", hash = "sha256:18bd1435cb1f2857ceb59cfb7de6f92593ef7b831ccd1b9bfb28ca530e539dce", size = 125989, upload-time = "2025-08-26T17:45:59.95Z" }, + { url = "https://files.pythonhosted.org/packages/ef/77/d3b1fef1fc6aaeed4cbf3be2b480114035f4df8fa1a99d2dac1d40d6e924/orjson-3.11.3-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:cf4b81227ec86935568c7edd78352a92e97af8da7bd70bdfdaa0d2e0011a1ab4", size = 238115, upload-time = "2025-08-26T17:46:01.669Z" }, + { url = "https://files.pythonhosted.org/packages/e4/6d/468d21d49bb12f900052edcfbf52c292022d0a323d7828dc6376e6319703/orjson-3.11.3-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:bc8bc85b81b6ac9fc4dae393a8c159b817f4c2c9dee5d12b773bddb3b95fc07e", size = 127493, upload-time = "2025-08-26T17:46:03.466Z" }, + { url = "https://files.pythonhosted.org/packages/67/46/1e2588700d354aacdf9e12cc2d98131fb8ac6f31ca65997bef3863edb8ff/orjson-3.11.3-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:88dcfc514cfd1b0de038443c7b3e6a9797ffb1b3674ef1fd14f701a13397f82d", size = 122998, upload-time = "2025-08-26T17:46:04.803Z" }, + { url = "https://files.pythonhosted.org/packages/3b/94/11137c9b6adb3779f1b34fd98be51608a14b430dbc02c6d41134fbba484c/orjson-3.11.3-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:d61cd543d69715d5fc0a690c7c6f8dcc307bc23abef9738957981885f5f38229", size = 132915, upload-time = "2025-08-26T17:46:06.237Z" }, + { url = "https://files.pythonhosted.org/packages/10/61/dccedcf9e9bcaac09fdabe9eaee0311ca92115699500efbd31950d878833/orjson-3.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2b7b153ed90ababadbef5c3eb39549f9476890d339cf47af563aea7e07db2451", size = 130907, upload-time = "2025-08-26T17:46:07.581Z" }, + { url = "https://files.pythonhosted.org/packages/0e/fd/0e935539aa7b08b3ca0f817d73034f7eb506792aae5ecc3b7c6e679cdf5f/orjson-3.11.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:7909ae2460f5f494fecbcd10613beafe40381fd0316e35d6acb5f3a05bfda167", size = 403852, upload-time = "2025-08-26T17:46:08.982Z" }, + { url = "https://files.pythonhosted.org/packages/4a/2b/50ae1a5505cd1043379132fdb2adb8a05f37b3e1ebffe94a5073321966fd/orjson-3.11.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:2030c01cbf77bc67bee7eef1e7e31ecf28649353987775e3583062c752da0077", size = 146309, upload-time = "2025-08-26T17:46:10.576Z" }, + { url = "https://files.pythonhosted.org/packages/cd/1d/a473c158e380ef6f32753b5f39a69028b25ec5be331c2049a2201bde2e19/orjson-3.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a0169ebd1cbd94b26c7a7ad282cf5c2744fce054133f959e02eb5265deae1872", size = 135424, upload-time = "2025-08-26T17:46:12.386Z" }, + { url = "https://files.pythonhosted.org/packages/da/09/17d9d2b60592890ff7382e591aa1d9afb202a266b180c3d4049b1ec70e4a/orjson-3.11.3-cp314-cp314-win32.whl", hash = "sha256:0c6d7328c200c349e3a4c6d8c83e0a5ad029bdc2d417f234152bf34842d0fc8d", size = 136266, upload-time = "2025-08-26T17:46:13.853Z" }, + { url = "https://files.pythonhosted.org/packages/15/58/358f6846410a6b4958b74734727e582ed971e13d335d6c7ce3e47730493e/orjson-3.11.3-cp314-cp314-win_amd64.whl", hash = "sha256:317bbe2c069bbc757b1a2e4105b64aacd3bc78279b66a6b9e51e846e4809f804", size = 131351, upload-time = "2025-08-26T17:46:15.27Z" }, + { url = "https://files.pythonhosted.org/packages/28/01/d6b274a0635be0468d4dbd9cafe80c47105937a0d42434e805e67cd2ed8b/orjson-3.11.3-cp314-cp314-win_arm64.whl", hash = "sha256:e8f6a7a27d7b7bec81bd5924163e9af03d49bbb63013f107b48eb5d16db711bc", size = 125985, upload-time = "2025-08-26T17:46:16.67Z" }, ] [[package]] @@ -2381,7 +2561,7 @@ wheels = [ [[package]] name = "posthog" -version = "6.7.4" +version = "6.7.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "backoff", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2391,9 +2571,9 @@ dependencies = [ { name = "six", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0f/40/d7f585e09e47f492ebaeb8048a8e2ce5d9f49a3896856a7a975cbc1484fa/posthog-6.7.4.tar.gz", hash = "sha256:2bfa74f321ac18efe4a48a256d62034a506ca95477af7efa32292ed488a742c5", size = 118209, upload-time = "2025-09-05T15:29:21.517Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/f3/d9055bcd190980730bdc600318b34290e85fcb0afb1e31f83cdc33f92615/posthog-6.7.5.tar.gz", hash = "sha256:f4f32b4a4b0df531ae8f80f255a33a49e8880c8c1b62712e6b640535e33a905f", size = 118558, upload-time = "2025-09-16T12:40:34.431Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/95/e795059ef73d480a7f11f1be201087f65207509525920897fb514a04914c/posthog-6.7.4-py3-none-any.whl", hash = "sha256:7f1872c53ec7e9a29b088a5a1ad03fa1be3b871d10d70c8bf6c2dafb91beaac5", size = 136409, upload-time = "2025-09-05T15:29:19.995Z" }, + { url = "https://files.pythonhosted.org/packages/42/b4/b40f8467252b4ff481e54a9767b211b4ff83114e6d0b6f481852d0ef3e46/posthog-6.7.5-py3-none-any.whl", hash = "sha256:95b00f915365939e63fa183635bad1caaf89cf4a24b63c8bb6983f2a22a56cb3", size = 136766, upload-time = "2025-09-16T12:40:32.741Z" }, ] [[package]]