weave-python 0.27.0__tar.gz → 0.28.0__tar.gz

{weave_python-0.27.0 → weave_python-0.28.0}/.github/workflows/generate.yaml

@@ -53,7 +53,6 @@ jobs:
         with:
           cache-dependency-glob: "uv.lock"
           enable-cache: true
-          pyproject-file: pyproject.toml
 
       - name: Clear out gen previous api gen files
         uses: weave-labs/ci/.github/actions/clean-generated-output-dir@main
@@ -65,15 +64,18 @@ jobs:
         with:
           working-directory: "weave/weavesql"
 
-      - name: Generate sql schema
-        run: sqlc generate
+      #      disabled until sqlc supports copyfrom command for python
+      #      https://github.com/sqlc-dev/sqlc-gen-python/pull/92
+      #
+      #      - name: Generate sqlc configuration
+      #        run: python3 tools/sqlcgen/sqlcgen.py --schema schema/weavesql
+      #
+      #      - name: Generate sql schema
+      #        run: sqlc generate
 
       - name: Generate proto schema
         run: buf generate
 
-      - name: Remove schema directory
-        run: rm -rf schema
-
       - name: Run uv sync
         run: uv sync
 

{weave_python-0.27.0 → weave_python-0.28.0}/.gitignore

@@ -328,3 +328,7 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
+### Custom
+
+schema/
+sqlc.yaml

{weave_python-0.27.0 → weave_python-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weave-python
-Version: 0.27.0
+Version: 0.28.0
 Requires-Python: >=3.10
 Requires-Dist: protobuf>=6.30.2
 Requires-Dist: sqlalchemy>=2.0.40

weave_python-0.28.0/tools/sqlcgen/README.md

@@ -0,0 +1,106 @@
+# sqlcgen - SQLC Configuration Generator for Python
+
+This tool automatically generates `sqlc.yaml` configuration for Python projects based on directories found in the
+schema/weavesql directory.
+
+## Usage
+
+From the `weave-python` directory:
+
+```bash
+python tools/sqlcgen/sqlcgen.py [options]
+```
+
+### Options
+
+- `--schema`: Path to schema directory containing database folders (default: "schema/weavesql")
+- `--output`: Output file path for generated sqlc.yaml (default: "sqlc.yaml")
+
+### Examples
+
+Generate configuration:
+
+```bash
+python tools/sqlcgen/sqlcgen.py
+```
+
+Use custom schema directory:
+
+```bash
+python tools/sqlcgen/sqlcgen.py --schema ../custom/schema --output custom-sqlc.yaml
+```
+
+## How it Works
+
+1. Scans the schema directory for subdirectories
+2. For each subdirectory that contains both `migrations/` and `queries/` folders:
+    - Creates an SQLC configuration entry
+    - Sets the package name as `{dirname}db` (e.g., `weave` → `weavedb`)
+    - Sets the output directory as `weave/weavesql/{package}`
+3. Generates a complete `sqlc.yaml` with all discovered databases
+
+## Example Structure
+
+Given this structure:
+
+```
+schema/weavesql/
+├── weave/
+│   ├── migrations/
+│   └── queries/
+└── llmx/
+    ├── migrations/
+    └── queries/
+```
+
+The tool will generate configurations for:
+
+- `weave` → package `weavedb`, output to `weave/weavesql/weavedb`
+- `llmx` → package `llmxdb`, output to `weave/weavesql/llmxdb`
+
+## Generated Configuration
+
+The tool generates sqlc.yaml with:
+
+- The sqlc Python plugin (sqlc-gen-python_1.3.0)
+- Both sync and async querier generation
+- String enum support
+- Query parameter limit of 2
+
+## Integration with CI/CD
+
+This tool is used in the GitHub Actions workflow to dynamically generate sqlc.yaml before running `sqlc generate`:
+
+```yaml
+- name: Generate sqlc configuration
+  run: python tools/sqlcgen/sqlcgen.py
+
+- name: Generate sql schema
+  run: sqlc generate
+```
+
+## Using with Task
+
+The project includes a Taskfile for common operations:
+
+```bash
+# Generate sqlc configuration
+task generate-sqlc-config
+
+# Generate all code (sqlc config + sqlc generate)
+task generate
+
+# Run tests for sqlcgen
+task test-sqlcgen
+
+# Clean generated files
+task clean
+
+# Show all available tasks
+task --list
+```
+
+## Requirements
+
+- Python 3.7+
+- No external dependencies (uses only Python standard library)

weave_python-0.28.0/tools/sqlcgen/sqlcgen.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+sqlcgen - SQLC Configuration Generator for Python projects
+
+This tool automatically generates sqlc.yaml configuration based on directories
+found in the schema/weavesql directory.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List, NamedTuple
+
+
+class Database(NamedTuple):
+    """Represents a database configuration."""
+
+    name: str  # e.g., "weave", "llmx"
+    package: str  # e.g., "weavedb", "llmxdb"
+
+
+def find_databases(schema_dir: Path) -> List[Database]:
+    """
+    Find all valid database directories in the schema directory.
+
+    A valid database directory must contain both 'migrations' and 'queries' subdirectories.
+
+    Args:
+        schema_dir: Path to the schema directory containing database folders
+
+    Returns:
+        List of Database objects sorted by name
+    """
+    databases = []
+
+    if not schema_dir.exists():
+        print(f"Schema directory {schema_dir} does not exist", file=sys.stderr)
+        sys.exit(1)
+
+    for entry in sorted(schema_dir.iterdir()):
+        if not entry.is_dir():
+            continue
+
+        # Skip hidden directories
+        if entry.name.startswith("."):
+            continue
+
+        # Check if migrations and queries directories exist
+        migrations_path = entry / "migrations"
+        queries_path = entry / "queries"
+
+        if not migrations_path.exists():
+            print(f"Skipping {entry.name}: migrations directory not found")
+            continue
+
+        if not queries_path.exists():
+            print(f"Skipping {entry.name}: queries directory not found")
+            continue
+
+        databases.append(Database(name=entry.name, package=f"{entry.name}db"))
+
+    return databases
+
+
+def generate_sqlc_config(
+    databases: List[Database], output_file: Path, schema_prefix: str = "schema/weavesql"
+):
+    """
+    Generate sqlc.yaml configuration for Python using the sqlc Python plugin.
+
+    Args:
+        databases: List of Database objects
+        output_file: Path where the generated config should be written
+        schema_prefix: Prefix path to schema directory
+    """
+    # Start with version and plugin configuration
+    config_lines = [
+        'version: "2"',
+        "plugins:",
+        "  - name: py",
+        "    wasm:",
+        "      url: https://downloads.sqlc.dev/plugin/sqlc-gen-python_1.3.0.wasm",
+        "      sha256: fbedae96b5ecae2380a70fb5b925fd4bff58a6cfb1f3140375d098fbab7b3a3c",
+        "sql:",
+    ]
+
+    for db in databases:
+        db_config = f'''  - schema: "{schema_prefix}/{db.name}/migrations"
+    queries: "{schema_prefix}/{db.name}/queries"
+    engine: "postgresql"
+    codegen:
+      - out: "weave/weavesql/{db.package}"
+        plugin: "py"
+        options:
+          package: "weave.weavesql.{db.package}"
+          emit_async_querier: true
+          emit_str_enum: true
+          emit_sync_querier: true
+          query_parameter_limit: 2'''
+        config_lines.append(db_config)
+
+    # Write output file
+    with open(output_file, "w") as f:
+        f.write("\n".join(config_lines) + "\n")
+
+    print(f"Generated {output_file} with {len(databases)} database configurations")
+    for db in databases:
+        print(f"  - {db.name} -> {db.package}")
+
+
+def main():
+    """Main entry point for the script."""
+    parser = argparse.ArgumentParser(
+        description="Generate sqlc.yaml configuration for Python projects from schema directories"
+    )
+    parser.add_argument(
+        "--schema",
+        type=str,
+        default="schema/weavesql",
+        help="Path to schema directory containing database folders (default: schema/weavesql)",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="sqlc.yaml",
+        help="Output file path for generated sqlc.yaml (default: sqlc.yaml)",
+    )
+
+    args = parser.parse_args()
+
+    # Convert paths
+    schema_dir = Path(args.schema)
+    output_file = Path(args.output)
+
+    # Find databases
+    databases = find_databases(schema_dir)
+
+    if not databases:
+        print("No valid database directories found")
+        sys.exit(0)
+
+    # Generate configuration
+    generate_sqlc_config(databases, output_file, schema_prefix=args.schema)
+
+
+if __name__ == "__main__":
+    main()

weave_python-0.28.0/tools/sqlcgen/test_sqlcgen.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""
+Tests for the sqlcgen tool.
+"""
+
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+import sys
+import os
+
+# Add the parent directory to the path so we can import sqlcgen
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import sqlcgen
+
+
+class TestSQLCGen(unittest.TestCase):
+    """Test cases for the sqlcgen tool."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        # Create a temporary directory for testing
+        self.test_dir = tempfile.TemporaryDirectory()
+        self.test_path = Path(self.test_dir.name)
+
+    def tearDown(self):
+        """Clean up test fixtures."""
+        self.test_dir.cleanup()
+
+    def create_test_schema(self, databases):
+        """
+        Create a test schema directory structure.
+
+        Args:
+            databases: List of database names to create
+        """
+        schema_dir = self.test_path / "schema" / "weavesql"
+        for db_name in databases:
+            db_dir = schema_dir / db_name
+            (db_dir / "migrations").mkdir(parents=True)
+            (db_dir / "queries").mkdir(parents=True)
+            # Create dummy files
+            (db_dir / "migrations" / "001_init.sql").touch()
+            (db_dir / "queries" / "queries.sql").touch()
+        return schema_dir
+
+    def test_find_databases_with_valid_structure(self):
+        """Test finding databases with valid directory structure."""
+        schema_dir = self.create_test_schema(["weave", "llmx", "modex"])
+
+        databases = sqlcgen.find_databases(schema_dir)
+
+        self.assertEqual(len(databases), 3)
+        self.assertEqual(databases[0].name, "llmx")
+        self.assertEqual(databases[0].package, "llmxdb")
+        self.assertEqual(databases[1].name, "modex")
+        self.assertEqual(databases[1].package, "modexdb")
+        self.assertEqual(databases[2].name, "weave")
+        self.assertEqual(databases[2].package, "weavedb")
+
+    def test_find_databases_skips_invalid_directories(self):
+        """Test that directories without migrations or queries are skipped."""
+        schema_dir = self.create_test_schema(["valid"])
+
+        # Create invalid directories
+        (schema_dir / "no_migrations").mkdir()
+        (schema_dir / "no_migrations" / "queries").mkdir()
+
+        (schema_dir / "no_queries").mkdir()
+        (schema_dir / "no_queries" / "migrations").mkdir()
+
+        (schema_dir / ".hidden").mkdir()
+        (schema_dir / ".hidden" / "migrations").mkdir()
+        (schema_dir / ".hidden" / "queries").mkdir()
+
+        # Create a file (not a directory)
+        (schema_dir / "not_a_dir.txt").touch()
+
+        databases = sqlcgen.find_databases(schema_dir)
+
+        # Should only find the valid database
+        self.assertEqual(len(databases), 1)
+        self.assertEqual(databases[0].name, "valid")
+
+    def test_find_databases_with_nonexistent_directory(self):
+        """Test that nonexistent directory causes exit."""
+        nonexistent = self.test_path / "nonexistent"
+
+        with self.assertRaises(SystemExit) as cm:
+            sqlcgen.find_databases(nonexistent)
+
+        self.assertEqual(cm.exception.code, 1)
+
+    def test_generate_sqlc_config(self):
+        """Test generation of sqlc.yaml configuration."""
+        databases = [
+            sqlcgen.Database("weave", "weavedb"),
+            sqlcgen.Database("llmx", "llmxdb"),
+        ]
+        output_file = self.test_path / "sqlc.yaml"
+
+        sqlcgen.generate_sqlc_config(databases, output_file)
+
+        # Check that file was created
+        self.assertTrue(output_file.exists())
+
+        # Read and verify content
+        content = output_file.read_text()
+
+        # Check for required elements
+        self.assertIn('version: "2"', content)
+        self.assertIn("plugins:", content)
+        self.assertIn("name: py", content)
+        self.assertIn("sqlc-gen-python_1.3.0.wasm", content)
+
+        # Check for database configurations
+        self.assertIn('schema: "schema/weavesql/weave/migrations"', content)
+        self.assertIn('queries: "schema/weavesql/weave/queries"', content)
+        self.assertIn('package: "weave.weavesql.weavedb"', content)
+        self.assertIn('out: "weave/weavesql/weavedb"', content)
+
+        self.assertIn('schema: "schema/weavesql/llmx/migrations"', content)
+        self.assertIn('queries: "schema/weavesql/llmx/queries"', content)
+        self.assertIn('package: "weave.weavesql.llmxdb"', content)
+        self.assertIn('out: "weave/weavesql/llmxdb"', content)
+
+        # Check for options
+        self.assertIn("emit_async_querier: true", content)
+        self.assertIn("emit_str_enum: true", content)
+        self.assertIn("emit_sync_querier: true", content)
+        self.assertIn("query_parameter_limit: 2", content)
+
+    def test_generate_sqlc_config_with_custom_schema_prefix(self):
+        """Test generation with custom schema prefix."""
+        databases = [
+            sqlcgen.Database("test", "testdb"),
+        ]
+        output_file = self.test_path / "sqlc.yaml"
+
+        sqlcgen.generate_sqlc_config(
+            databases, output_file, schema_prefix="custom/path"
+        )
+
+        content = output_file.read_text()
+        self.assertIn('schema: "custom/path/test/migrations"', content)
+        self.assertIn('queries: "custom/path/test/queries"', content)
+
+    def test_main_integration(self):
+        """Test the main function with real directory structure."""
+        schema_dir = self.create_test_schema(["db1", "db2"])
+        output_file = self.test_path / "output.yaml"
+
+        # Mock sys.argv
+        test_args = [
+            "sqlcgen.py",
+            "--schema",
+            str(schema_dir),
+            "--output",
+            str(output_file),
+        ]
+
+        with patch.object(sys, "argv", test_args):
+            sqlcgen.main()
+
+        # Verify output file was created
+        self.assertTrue(output_file.exists())
+
+        # Verify content
+        content = output_file.read_text()
+        self.assertIn("db1", content)
+        self.assertIn("db2", content)
+        self.assertIn("db1db", content)
+        self.assertIn("db2db", content)
+
+    def test_main_with_no_databases(self):
+        """Test main function when no valid databases are found."""
+        empty_dir = self.test_path / "empty"
+        empty_dir.mkdir()
+        output_file = self.test_path / "output.yaml"
+
+        test_args = [
+            "sqlcgen.py",
+            "--schema",
+            str(empty_dir),
+            "--output",
+            str(output_file),
+        ]
+
+        with patch.object(sys, "argv", test_args):
+            with self.assertRaises(SystemExit) as cm:
+                sqlcgen.main()
+
+            # Should exit with code 0 (not an error, just no databases)
+            self.assertEqual(cm.exception.code, 0)
+
+        # Output file should not be created
+        self.assertFalse(output_file.exists())
+
+    def test_database_namedtuple(self):
+        """Test the Database namedtuple."""
+        db = sqlcgen.Database("mydb", "mydbpkg")
+        self.assertEqual(db.name, "mydb")
+        self.assertEqual(db.package, "mydbpkg")
+
+    def test_sorting_of_databases(self):
+        """Test that databases are sorted alphabetically."""
+        schema_dir = self.create_test_schema(["zebra", "alpha", "beta"])
+
+        databases = sqlcgen.find_databases(schema_dir)
+
+        # Should be sorted alphabetically
+        self.assertEqual(databases[0].name, "alpha")
+        self.assertEqual(databases[1].name, "beta")
+        self.assertEqual(databases[2].name, "zebra")
+
+
+class TestSQLCGenOutput(unittest.TestCase):
+    """Test the actual output format of generated configurations."""
+
+    def test_yaml_structure(self):
+        """Test that the generated YAML has the correct structure."""
+        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml", delete=False) as f:
+            databases = [
+                sqlcgen.Database("test", "testdb"),
+            ]
+            output_file = Path(f.name)
+
+            sqlcgen.generate_sqlc_config(databases, output_file)
+
+            # Read and parse line by line to check structure
+            lines = output_file.read_text().splitlines()
+
+            # Check indentation and structure
+            self.assertEqual(lines[0], 'version: "2"')
+            self.assertEqual(lines[1], "plugins:")
+            self.assertTrue(lines[2].startswith("  - name:"))
+
+            # Find sql section
+            sql_line = next(i for i, line in enumerate(lines) if line == "sql:")
+            self.assertTrue(sql_line > 0)
+
+            # Check database configuration starts with proper indentation
+            db_start = sql_line + 1
+            self.assertTrue(lines[db_start].startswith("  - schema:"))
+
+            # Clean up
+            output_file.unlink()
+
+    def test_multiple_databases_formatting(self):
+        """Test formatting with multiple databases."""
+        with tempfile.NamedTemporaryFile(mode="w+", suffix=".yaml", delete=False) as f:
+            databases = [
+                sqlcgen.Database("first", "firstdb"),
+                sqlcgen.Database("second", "seconddb"),
+            ]
+            output_file = Path(f.name)
+
+            sqlcgen.generate_sqlc_config(databases, output_file)
+
+            content = output_file.read_text()
+
+            # Count database entries
+            schema_count = content.count("  - schema:")
+            self.assertEqual(schema_count, 2)
+
+            # Verify each database has all required fields
+            for db in databases:
+                self.assertIn(
+                    f'schema: "schema/weavesql/{db.name}/migrations"', content
+                )
+                self.assertIn(f'queries: "schema/weavesql/{db.name}/queries"', content)
+                self.assertIn(f'package: "weave.weavesql.{db.package}"', content)
+
+            # Clean up
+            output_file.unlink()
+
+
+if __name__ == "__main__":
+    unittest.main()

{weave_python-0.27.0 → weave_python-0.28.0}/uv.lock

@@ -55,16 +55,16 @@ wheels = [
 
 [[package]]
 name = "protobuf"
-version = "6.31.1"
+version = "6.32.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/52/f3/b9655a711b32c19720253f6f06326faf90580834e2e83f840472d752bc8b/protobuf-6.31.1.tar.gz", hash = "sha256:d8cac4c982f0b957a4dc73a80e2ea24fab08e679c0de9deb835f4a12d69aca9a", size = 441797, upload-time = "2025-05-28T19:25:54.947Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/df/fb4a8eeea482eca989b51cffd274aac2ee24e825f0bf3cbce5281fa1567b/protobuf-6.32.0.tar.gz", hash = "sha256:a81439049127067fc49ec1d36e25c6ee1d1a2b7be930675f919258d03c04e7d2", size = 440614, upload-time = "2025-08-14T21:21:25.015Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/6f/6ab8e4bf962fd5570d3deaa2d5c38f0a363f57b4501047b5ebeb83ab1125/protobuf-6.31.1-cp310-abi3-win32.whl", hash = "sha256:7fa17d5a29c2e04b7d90e5e32388b8bfd0e7107cd8e616feef7ed3fa6bdab5c9", size = 423603, upload-time = "2025-05-28T19:25:41.198Z" },
-    { url = "https://files.pythonhosted.org/packages/44/3a/b15c4347dd4bf3a1b0ee882f384623e2063bb5cf9fa9d57990a4f7df2fb6/protobuf-6.31.1-cp310-abi3-win_amd64.whl", hash = "sha256:426f59d2964864a1a366254fa703b8632dcec0790d8862d30034d8245e1cd447", size = 435283, upload-time = "2025-05-28T19:25:44.275Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/c9/b9689a2a250264a84e66c46d8862ba788ee7a641cdca39bccf64f59284b7/protobuf-6.31.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:6f1227473dc43d44ed644425268eb7c2e488ae245d51c6866d19fe158e207402", size = 425604, upload-time = "2025-05-28T19:25:45.702Z" },
-    { url = "https://files.pythonhosted.org/packages/76/a1/7a5a94032c83375e4fe7e7f56e3976ea6ac90c5e85fac8576409e25c39c3/protobuf-6.31.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:a40fc12b84c154884d7d4c4ebd675d5b3b5283e155f324049ae396b95ddebc39", size = 322115, upload-time = "2025-05-28T19:25:47.128Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/b1/b59d405d64d31999244643d88c45c8241c58f17cc887e73bcb90602327f8/protobuf-6.31.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:4ee898bf66f7a8b0bd21bce523814e6fbd8c6add948045ce958b73af7e8878c6", size = 321070, upload-time = "2025-05-28T19:25:50.036Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/af/ab3c51ab7507a7325e98ffe691d9495ee3d3aa5f589afad65ec920d39821/protobuf-6.31.1-py3-none-any.whl", hash = "sha256:720a6c7e6b77288b85063569baae8536671b39f15cc22037ec7045658d80489e", size = 168724, upload-time = "2025-05-28T19:25:53.926Z" },
+    { url = "https://files.pythonhosted.org/packages/33/18/df8c87da2e47f4f1dcc5153a81cd6bca4e429803f4069a299e236e4dd510/protobuf-6.32.0-cp310-abi3-win32.whl", hash = "sha256:84f9e3c1ff6fb0308dbacb0950d8aa90694b0d0ee68e75719cb044b7078fe741", size = 424409, upload-time = "2025-08-14T21:21:12.366Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/59/0a820b7310f8139bd8d5a9388e6a38e1786d179d6f33998448609296c229/protobuf-6.32.0-cp310-abi3-win_amd64.whl", hash = "sha256:a8bdbb2f009cfc22a36d031f22a625a38b615b5e19e558a7b756b3279723e68e", size = 435735, upload-time = "2025-08-14T21:21:15.046Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/5b/0d421533c59c789e9c9894683efac582c06246bf24bb26b753b149bd88e4/protobuf-6.32.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d52691e5bee6c860fff9a1c86ad26a13afbeb4b168cd4445c922b7e2cf85aaf0", size = 426449, upload-time = "2025-08-14T21:21:16.687Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/7b/607764ebe6c7a23dcee06e054fd1de3d5841b7648a90fd6def9a3bb58c5e/protobuf-6.32.0-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:501fe6372fd1c8ea2a30b4d9be8f87955a64d6be9c88a973996cef5ef6f0abf1", size = 322869, upload-time = "2025-08-14T21:21:18.282Z" },
+    { url = "https://files.pythonhosted.org/packages/40/01/2e730bd1c25392fc32e3268e02446f0d77cb51a2c3a8486b1798e34d5805/protobuf-6.32.0-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:75a2aab2bd1aeb1f5dc7c5f33bcb11d82ea8c055c9becbb41c26a8c43fd7092c", size = 322009, upload-time = "2025-08-14T21:21:19.893Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/f2/80ffc4677aac1bc3519b26bc7f7f5de7fce0ee2f7e36e59e27d8beb32dd1/protobuf-6.32.0-py3-none-any.whl", hash = "sha256:ba377e5b67b908c8f3072a57b63e2c6a4cbd18aea4ed98d2584350dbf46f2783", size = 169287, upload-time = "2025-08-14T21:21:23.515Z" },
 ]
 
 [[package]]