chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/tools/test_virtual_project.py

@@ -0,0 +1,591 @@
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path
+from typing import Any, Callable
+
+import click
+import pytest
+import yaml
+from click.testing import CliRunner
+
+from chia.util.virtual_project_analysis import (
+    Annotation,
+    ChiaFile,
+    Config,
+    DirectoryParameters,
+    File,
+    Package,
+    build_dependency_graph,
+    build_virtual_dependency_graph,
+    cli,
+    config,
+    find_cycles,
+    parse_file_or_package,
+)
+
+
+@pytest.mark.parametrize(
+    "file_string, expected, annotated",
+    [
+        ("# Package: example\n# Some other comment", "example", True),
+        ("# Some comment\n# Some other comment", "chia-blockchain", False),
+    ],
+)
+def test_parse_annotation(file_string: str, expected: str, annotated: bool) -> None:
+    """
+    Test that parse returns an Annotation instance for a valid annotation or
+    raises ValueError for an invalid one.
+    """
+    annotation = Annotation.parse(file_string)
+    assert isinstance(annotation, Annotation)
+    assert annotation.package == expected
+    assert annotation.is_annotated == annotated
+
+
+# Temporary directory fixture to create test files
+@pytest.fixture
+def create_test_file(tmp_path: Path) -> Callable[[str, str], Path]:
+    def _create_test_file(name: str, content: str) -> Path:
+        file_path = tmp_path / name
+        file_path.write_text(content, encoding="utf-8")
+        return file_path
+
+    return _create_test_file
+
+
+def test_parse_with_annotation(create_test_file: Callable[[str, str], Path]) -> None:
+    """Test parsing a file that contains a valid annotation."""
+    file_content = "# Package: test_package\n# Some other comment"
+    test_file = create_test_file("annotated_file.txt", file_content)
+
+    parsed_file = ChiaFile.parse(test_file)
+
+    assert parsed_file.path == test_file
+    assert isinstance(parsed_file.annotations, Annotation)
+    assert parsed_file.annotations.package == "test_package"
+
+
+def test_parse_without_annotation(create_test_file: Callable[[str, str], Path]) -> None:
+    """Test parsing a file that does not contain any annotations."""
+    file_content = "# Some comment\n# Some other comment"
+    test_file = create_test_file("non_annotated_file.txt", file_content)
+
+    parsed_file = ChiaFile.parse(test_file)
+
+    assert parsed_file.path == test_file
+    assert not parsed_file.annotations.is_annotated
+
+
+# This test is optional and can be adapted based on expected behavior for non-existent files
+def test_parse_nonexistent_file() -> None:
+    """Test attempting to parse a non-existent file."""
+    with pytest.raises(FileNotFoundError):
+        ChiaFile.parse(Path("/path/to/nonexistent/file.txt"))
+
+
+# Helper function to create a non-empty Python file
+def create_python_file(dir_path: Path, name: str, content: str) -> Path:
+    file_path = dir_path / name
+    file_path.write_text(content, encoding="utf-8")
+    return file_path
+
+
+# Helper function to create an empty Python file
+def create_empty_python_file(dir_path: Path, name: str) -> Path:
+    file_path = dir_path / name
+    file_path.touch()
+    return file_path
+
+
+def test_gather_non_empty_python_files(tmp_path: Path) -> None:
+    # Set up directory structure
+    dir_path = tmp_path / "test_dir"
+    dir_path.mkdir()
+    excluded_dir = tmp_path / "excluded_dir"
+    excluded_dir.mkdir()
+
+    # Create test files
+    non_empty_file = create_python_file(dir_path, "non_empty.py", "print('Hello World')")
+    create_empty_python_file(dir_path, "empty.py")
+    create_python_file(excluded_dir, "excluded.py", "print('Hello World')")
+
+    # Initialize DirectoryParameters with excluded paths
+    dir_params = DirectoryParameters(dir_path=dir_path, excluded_paths=[excluded_dir])
+
+    # Perform the test
+    python_files = dir_params.gather_non_empty_python_files()
+
+    # Assertions
+    assert len(python_files) == 1  # Only one non-empty Python file should be found
+    assert python_files[0].path == non_empty_file  # The path of the gathered file should match the non-empty file
+
+
+def test_gather_with_nested_directories_and_exclusions(tmp_path: Path) -> None:
+    # Set up directory structure
+    base_dir = tmp_path / "base_dir"
+    base_dir.mkdir()
+    nested_dir = base_dir / "nested_dir"
+    nested_dir.mkdir()
+    excluded_dir = base_dir / "excluded_dir"
+    excluded_dir.mkdir()
+
+    # Create test files
+    nested_file = create_python_file(nested_dir, "nested.py", "print('Hello World')")
+    create_empty_python_file(nested_dir, "nested_empty.py")
+    create_python_file(excluded_dir, "excluded.py", "print('Hello World')")
+
+    # Initialize DirectoryParameters without excluded paths
+    dir_params = DirectoryParameters(dir_path=base_dir, excluded_paths=[excluded_dir])
+
+    # Perform the test
+    python_files = dir_params.gather_non_empty_python_files()
+
+    # Assertions
+    assert len(python_files) == 1  # Only the non-empty Python file in the nested directory should be found
+    assert python_files[0].path == nested_file  # The path of the gathered file should match the nested non-empty file
+
+
+def test_find_missing_annotations(tmp_path: Path) -> None:
+    # Set up directory structure
+    dir_path = tmp_path / "test_dir"
+    dir_path.mkdir()
+
+    # Create test files
+    create_python_file(dir_path, "non_empty.py", "print('Hello World')")
+
+    # Run the command
+    runner = CliRunner()
+    result = runner.invoke(cli, ["find_missing_annotations", "--directory", str(dir_path)])
+    assert result.output == f"{dir_path / 'non_empty.py'}\n"
+
+    # Rewrite file to have annotation
+    create_python_file(dir_path, "non_empty.py", "# Package: misc\n")
+
+    # Run the command again with no results
+    result = runner.invoke(cli, ["find_missing_annotations", "--directory", str(dir_path)])
+    assert result.output == ""
+
+
+def test_parse_file_or_package() -> None:
+    assert parse_file_or_package("example.py") == File(Path("example.py"))
+    assert parse_file_or_package("example.py (extra info)") == File(Path("example.py"))
+    assert parse_file_or_package("(package_name)") == Package("package_name")
+    assert parse_file_or_package("package_name") == Package("package_name")
+    assert parse_file_or_package("package_name(") == Package("package_name(")
+    assert parse_file_or_package("(package_name") == Package("(package_name")
+    assert parse_file_or_package("package_name)") == Package("package_name)")
+
+
+@pytest.fixture
+def chia_package_structure(tmp_path: Path) -> Path:
+    base_dir = tmp_path / "chia_project"
+    base_dir.mkdir()
+    chia_dir = base_dir / "chia"
+    chia_dir.mkdir()
+
+    # Create some files within the chia package
+    create_python_file(chia_dir, "module1.py", "def func1(): pass")
+    create_python_file(chia_dir, "module2.py", "def func2(): pass\nfrom chia.module1 import func1")
+    create_python_file(chia_dir, "module3.py", "def func3(): pass\nimport chia.module2")
+
+    return chia_dir
+
+
+def test_build_dependency_graph(chia_package_structure: Path) -> None:
+    chia_dir = chia_package_structure
+    dir_params = DirectoryParameters(dir_path=chia_dir)
+    graph = build_dependency_graph(dir_params)
+    assert chia_dir / "module1.py" in graph
+    assert chia_dir / "module2.py" in graph
+    assert chia_dir / "module3.py" in graph
+    assert chia_dir / "module1.py" in graph[chia_dir / "module2.py"]
+    assert chia_dir / "module2.py" in graph[chia_dir / "module3.py"]
+
+
+def test_print_dependency_graph(chia_package_structure: Path) -> None:
+    # Run the command
+    runner = CliRunner()
+    result = runner.invoke(cli, ["print_dependency_graph", "--directory", str(chia_package_structure)])
+    assert "module1.py" in result.output
+    assert "module2.py" in result.output
+    assert "module3.py" in result.output
+
+
+# Mock the build_dependency_graph function to control its output
+def mock_build_dependency_graph(dir_params: DirectoryParameters) -> dict[Path, list[Path]]:
+    return {
+        Path("/path/to/package1/module1.py"): [
+            Path("/path/to/package2/module2.py"),
+            Path("/path/to/package3/module3.py"),
+        ],
+        Path("/path/to/package2/module2.py"): [],
+        Path("/path/to/package3/module3.py"): [Path("/path/to/package2/module2.py")],
+    }
+
+
+# Helper function to simulate ChiaFile.parse for testing
+def mock_chia_file_parse(path: Path) -> ChiaFile:
+    annotations_map = {
+        Path("/path/to/package1/module1.py"): Annotation("Package1", True),
+        Path("/path/to/package2/module2.py"): Annotation("Package2", True),
+        Path("/path/to/package3/module3.py"): Annotation("Package3", True),
+    }
+    return ChiaFile(path=Path(path), annotations=annotations_map.get(path, Annotation("chia-blockchain", False)))
+
+
+@pytest.fixture
+def prepare_mocks(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("chia.util.virtual_project_analysis.build_dependency_graph", mock_build_dependency_graph)
+    monkeypatch.setattr("chia.util.virtual_project_analysis.ChiaFile.parse", mock_chia_file_parse)
+
+
+def test_build_virtual_dependency_graph(prepare_mocks: None) -> None:
+    dir_params = DirectoryParameters(dir_path=Path("/path/to/package1"))
+    virtual_graph = build_virtual_dependency_graph(dir_params)
+
+    assert "Package2" in virtual_graph["Package1"]
+    assert "Package3" in virtual_graph["Package1"]
+    assert virtual_graph["Package2"] == []
+    assert "Package2" in virtual_graph["Package3"]
+
+
+def test_print_virtual_dependency_graph(tmp_path: Path) -> None:
+    chia_dir = tmp_path / "chia"
+    chia_dir.mkdir()
+
+    # Create some files within the chia package
+    create_python_file(chia_dir, "module1.py", "# Package: one\ndef func1(): pass")
+    create_python_file(chia_dir, "module2.py", "# Package: two\ndef func2(): pass\nfrom chia.module1 import func1")
+    create_python_file(chia_dir, "module3.py", "# Package: three\ndef func3(): pass\nimport chia.module2")
+
+    # Run the command
+    runner = CliRunner()
+    result = runner.invoke(cli, ["print_virtual_dependency_graph", "--directory", str(chia_dir)])
+    assert "one" in result.output
+    assert "two" in result.output
+    assert "three" in result.output
+
+
+# Helper function to simulate ChiaFile.parse for testing
+def mock_chia_file_parse2(path: Path) -> ChiaFile:
+    annotations_map = {
+        Path("/path/to/package1/module1.py"): Annotation("Package1", True),
+        Path("/path/to/package2/module2.py"): Annotation("Package2", True),
+        Path("/path/to/package3/module3.py"): Annotation("Package1", True),
+    }
+    return ChiaFile(path=Path(path), annotations=annotations_map.get(path, Annotation("chia-blockchain", False)))
+
+
+@pytest.fixture
+def prepare_mocks2(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("chia.util.virtual_project_analysis.ChiaFile.parse", mock_chia_file_parse2)
+
+
+def test_cycle_detection(prepare_mocks2: None) -> None:
+    # Example graph with a simple cycle
+    graph: dict[Path, list[Path]] = {
+        Path("/path/to/package1/module1.py"): [Path("/path/to/package2/module2.py")],
+        Path("/path/to/package2/module2.py"): [Path("/path/to/package3/module3.py")],  # Cycle here
+        Path("/path/to/package3/module3.py"): [],
+    }
+    cycles = find_cycles(
+        graph,
+        build_virtual_dependency_graph(DirectoryParameters(dir_path=Path("path")), existing_graph=graph),
+        excluded_paths=[],
+        ignore_cycles_in=[],
+        ignore_specific_files=[],
+        ignore_specific_edges=[],
+    )
+    # \path\to\package1\module1.py (Package1) -> \path\to\package2\module2.py (Package2) -> (Package1)
+    # \path\to\package2\module2.py (Package2) -> \path\to\package3\module3.py (Package1) -> (Package2)
+    assert len(cycles) == 2
+
+
+def test_print_cycles(tmp_path: Path) -> None:
+    chia_dir = tmp_path / "chia"
+    chia_dir.mkdir()
+
+    # Create some files within the chia package
+    create_python_file(chia_dir, "module1.py", "# Package: one\ndef func1(): pass\nfrom chia.module2 import func2")
+    create_python_file(chia_dir, "module2.py", "# Package: two\ndef func2(): pass\nfrom chia.module3 import func3")
+    create_python_file(chia_dir, "module3.py", "# Package: one\ndef func3(): pass\n")
+
+    # Run the command
+    runner = CliRunner()
+    result = runner.invoke(cli, ["print_cycles", "--directory", str(chia_dir)])
+    assert "module1.py (one) -> " in result.output
+
+
+def test_check_config(tmp_path: Path) -> None:
+    chia_dir = tmp_path / "chia"
+    chia_dir.mkdir()
+
+    # Create some files within the chia package
+    create_python_file(
+        chia_dir,
+        "module1.py",
+        textwrap.dedent(
+            """
+            # Package: one
+            def func1(): pass
+            from chia.module2 import func2
+            """
+        ),
+    )
+    create_python_file(
+        chia_dir,
+        "module1b.py",
+        textwrap.dedent(
+            """
+            # Package: one
+            def func1b(): pass
+            """
+        ),
+    )
+    create_python_file(
+        chia_dir,
+        "module2.py",
+        textwrap.dedent(
+            """
+            # Package: two
+            def func2(): pass
+            from chia.module3 import func3
+            from chia.module1b import func1b
+            """
+        ),
+    )
+    create_python_file(
+        chia_dir,
+        "module3.py",
+        textwrap.dedent(
+            """
+            # Package: three
+            def func3(): pass
+            """
+        ),
+    )
+
+    # Run the command
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        [
+            "check_config",
+            "--directory",
+            str(chia_dir),
+            "--ignore-cycles-in",
+            "three",
+            "--ignore-specific-file",
+            str(chia_dir / "module3.py"),
+            "--ignore-specific-edge",
+            str(chia_dir / "module2.py") + " -> " + str(chia_dir / "module3.py"),
+            "--ignore-specific-edge",
+            str(chia_dir / "module2.py") + " -> " + str(chia_dir / "module1b.py"),
+        ],
+    )
+    assert "    module three ignored but no cycles were found" in result.output
+    assert f"    file {chia_dir / 'module3.py'!s} ignored but no cycles were found" in result.output
+    assert (
+        f"edge {str(chia_dir / 'module2.py') + ' -> ' + str(chia_dir / 'module3.py')} ignored but no cycles were found"
+        in result.output
+    )
+    assert (
+        f"edge {str(chia_dir / 'module2.py') + ' -> ' + str(chia_dir / 'module1b.py')} ignored but no cycles were found"
+        not in result.output
+    )
+
+
+def test_excluded_paths_handling(prepare_mocks2: None) -> None:
+    # Graph where module2.py is excluded
+    graph = {
+        Path("/path/to/package1/module1.py"): [Path("/path/to/package2/module2.py")],
+        Path("/path/to/package2/module2.py"): [Path("/path/to/package1/module1.py")],
+    }
+    cycles = find_cycles(
+        graph,
+        build_virtual_dependency_graph(DirectoryParameters(dir_path=Path("path")), existing_graph=graph),
+        excluded_paths=[Path("/path/to/package2/module2.py")],
+        ignore_cycles_in=[],
+        ignore_specific_files=[],
+        ignore_specific_edges=[],
+    )
+    assert len(cycles) == 0  # No cycles due to exclusion
+
+
+def test_ignore_cycles_in_specific_packages(prepare_mocks2: None) -> None:
+    graph: dict[Path, list[Path]] = {
+        Path("/path/to/package1/module1.py"): [Path("/path/to/package2/module2.py")],
+        Path("/path/to/package2/module2.py"): [Path("/path/to/package3/module3.py")],
+        Path("/path/to/package3/module3.py"): [],
+    }
+    # Assuming module1.py and module3.py belong to Package1, which is ignored
+    cycles = find_cycles(
+        graph,
+        build_virtual_dependency_graph(DirectoryParameters(dir_path=Path("path")), existing_graph=graph),
+        excluded_paths=[],
+        ignore_cycles_in=["Package1"],
+        ignore_specific_files=[],
+        ignore_specific_edges=[],
+    )
+    assert len(cycles) == 1  # Cycles in Package1 are ignored
+
+
+def test_ignore_cycles_with_specific_edges(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _mock_chia_file_parse(path: Path) -> ChiaFile:
+        annotations_map = {
+            Path("/path/to/package1/module1a.py"): Annotation("Package1", True),
+            Path("/path/to/package2/module2.py"): Annotation("Package2", True),
+            Path("/path/to/package3/module3.py"): Annotation("Package3", True),
+            Path("/path/to/package1/module1b.py"): Annotation("Package1", True),
+        }
+        return ChiaFile(path=Path(path), annotations=annotations_map.get(path, Annotation("chia-blockchain", False)))
+
+    monkeypatch.setattr("chia.util.virtual_project_analysis.ChiaFile.parse", _mock_chia_file_parse)
+
+    graph = {
+        Path("/path/to/package1/module1a.py"): [Path("/path/to/package2/module2.py")],
+        Path("/path/to/package2/module2.py"): [Path("/path/to/package3/module3.py")],
+        Path("/path/to/package3/module3.py"): [Path("/path/to/package1/module1b.py")],
+        Path("/path/to/package1/module1b.py"): [],
+    }
+    virtual_graph = build_virtual_dependency_graph(DirectoryParameters(dir_path=Path("path")), existing_graph=graph)
+    cycles = find_cycles(
+        graph,
+        virtual_graph,
+        excluded_paths=[],
+        ignore_cycles_in=[],
+        ignore_specific_files=[],
+        ignore_specific_edges=[
+            (File(Path("/path/to/package3/module3.py")), File(Path("/path/to/package2/module2.py"))),
+            (Package("Package3"), Package("Package2")),
+        ],
+    )
+    assert len(cycles) == 0
+
+
+def test_ignore_cycles_with_specific_files(prepare_mocks2: None) -> None:
+    graph = {
+        Path("/path/to/package1/module1.py"): [Path("/path/to/package2/module2.py")],
+        Path("/path/to/package2/module2.py"): [Path("/path/to/package3/module3.py")],  # Cycle here
+    }
+    cycles = find_cycles(
+        graph,
+        build_virtual_dependency_graph(DirectoryParameters(dir_path=Path("path")), existing_graph=graph),
+        excluded_paths=[],
+        ignore_cycles_in=[],
+        ignore_specific_files=[Path("/path/to/package1/module1.py"), Path("/path/to/package2/module2.py")],
+        ignore_specific_edges=[],
+    )
+    assert len(cycles) == 0
+
+
+# Sample function to use with the decorator for testing
+@click.command("blah")
+@config
+def sample_function(config: Config) -> None:
+    print(config)
+
+
+# Helper function to create a temporary YAML configuration file
+@pytest.fixture
+def create_yaml_config(tmp_path: Path) -> Callable[[dict[str, Any]], Path]:
+    def _create_yaml_config(content: dict[str, Any]) -> Path:
+        path = tmp_path / "config.yaml"
+        with open(path, "w") as f:
+            yaml.dump(content, f)
+        return path
+
+    return _create_yaml_config
+
+
+def test_config_with_yaml(create_yaml_config: Callable[[dict[str, Any]], Path]) -> None:
+    # Create a temporary YAML configuration file
+    yaml_config = {
+        "exclude_paths": ["path/to/exclude"],
+        "ignore": {
+            "packages": ["ignored.package"],
+            "files": ["ignored_file.py"],
+            "edges": ["ignored_parent -> ignored_child"],
+        },
+    }
+    config_path = create_yaml_config(yaml_config)
+
+    runner = CliRunner()
+
+    # Invoke the CLI with the --config option
+    result = runner.invoke(sample_function, ["--directory", ".", "--config", str(config_path)])
+
+    # Check if the command ran successfully
+    assert result.exit_code == 0
+
+    # Verify the config object created by the decorator
+    config = result.output
+    path_type = config_path.__class__.__name__
+    assert config == (
+        "Config("
+        "directory_parameters=DirectoryParameters("
+        f"dir_path={path_type}('.'), "
+        f"excluded_paths=[{path_type}('path/to/exclude')]"
+        "), "
+        "ignore_cycles_in=['ignored.package'], "
+        f"ignore_specific_files=[{path_type}('ignored_file.py')], "
+        f"ignore_specific_edges=[(Package(name='ignored_child', is_file=False), "
+        f"Package(name='ignored_parent', is_file=False))]"
+        ")\n"
+    )
+
+
+def test_parse_edges(tmp_path: Path) -> None:
+    chia_dir = tmp_path / "chia"
+    chia_dir.mkdir()
+
+    # Create some files within the chia package
+    create_python_file(
+        chia_dir,
+        "module1.py",
+        textwrap.dedent(
+            """
+            # Package: one
+            def func1(): pass
+            from chia.module2 import func2
+            from chia.module3 import func3
+            """
+        ),
+    )
+    create_python_file(
+        chia_dir,
+        "module2.py",
+        textwrap.dedent(
+            """
+            # Package: two
+            def func2(): pass
+            """
+        ),
+    )
+    create_python_file(
+        chia_dir,
+        "module3.py",
+        textwrap.dedent(
+            """
+            # Package: three
+            def func3(): pass
+            """
+        ),
+    )
+
+    # Run the command
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        [
+            "print_edges",
+            "--directory",
+            str(chia_dir),
+            "--dependent-package",
+            "one",
+            "--provider-package",
+            "two",
+        ],
+    )
+    assert result.output.strip() == f"{chia_dir / 'module1.py'!s} (one) -> {chia_dir / 'module2.py'!s} (two)"

chia/_tests/util/benchmark_cost.py

@@ -66,15 +66,15 @@ def benchmark_all_operators():
     point_add = "(point_add"
     " (q 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb)"
     " (q 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb))"
-    point_add_cost, point_add_time = run_and_return_cost_time(point_add)
+    _point_add_cost, point_add_time = run_and_return_cost_time(point_add)
     addition_cost, addition_time = run_and_return_cost_time(addition)
-    substraction_cost, substraction_time = run_and_return_cost_time(substraction)
-    multiply_cost, multiply_time = run_and_return_cost_time(multiply)
-    greater_cost, greater_time = run_and_return_cost_time(greater)
-    equal_cost, equal_time = run_and_return_cost_time(equal)
-    if_cost, if_time = run_and_return_cost_time(if_clvm)
-    sha256tree_cost, sha256tree_time = run_and_return_cost_time(sha256tree)
-    pubkey_for_exp_cost, pubkey_for_exp_time = run_and_return_cost_time(pubkey_for_exp)
+    _substraction_cost, substraction_time = run_and_return_cost_time(substraction)
+    _multiply_cost, multiply_time = run_and_return_cost_time(multiply)
+    _greater_cost, greater_time = run_and_return_cost_time(greater)
+    _equal_cost, equal_time = run_and_return_cost_time(equal)
+    _if_cost, if_time = run_and_return_cost_time(if_clvm)
+    _sha256tree_cost, sha256tree_time = run_and_return_cost_time(sha256tree)
+    _pubkey_for_exp_cost, pubkey_for_exp_time = run_and_return_cost_time(pubkey_for_exp)
 
     one_addition = 1
     one_substraction = get_cost_compared_to_addition(addition_cost, addition_time, substraction_time) / addition_cost
@@ -167,4 +167,4 @@ if __name__ == "__main__":
     constant = clvm_should_cost / clvm_cost
     format = float_to_str(constant)
     print(f"Constant factor: {format}")
-    print(f"CLVM RATIO MULTIPLIER: {1/constant}")
+    print(f"CLVM RATIO MULTIPLIER: {1 / constant}")

chia/_tests/util/benchmarks.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import random
-from typing import Tuple
 
 import importlib_resources
 from chia_rs import AugSchemeMPL, ClassgroupElement, Coin, G1Element, G2Element, VDFInfo, VDFProof
@@ -24,7 +23,7 @@ clvm_generator_bin_path = importlib_resources.files(__name__.rpartition(".")[0])
 clvm_generator = clvm_generator_bin_path.read_bytes()
 
 
-def rewards(height: uint32) -> Tuple[Coin, Coin]:
+def rewards(height: uint32) -> tuple[Coin, Coin]:
     farmer_coin = create_farmer_coin(height, ph, uint64(250000000), DEFAULT_CONSTANTS.GENESIS_CHALLENGE)
     pool_coin = create_pool_coin(height, ph, uint64(1750000000), DEFAULT_CONSTANTS.GENESIS_CHALLENGE)
     return farmer_coin, pool_coin