pyrig 2.2.6__py3-none-any.whl

pyrig/dev/cli/commands/create_tests.py

@@ -0,0 +1,244 @@
+"""Utilities for automatically creating test files for the project.
+
+This module provides functions to generate test files for all modules and classes
+in the project, ensuring that every function and method has a corresponding test.
+It creates the basic test structure and generates skeleton test functions with
+NotImplementedError to indicate tests that need to be written.
+"""
+
+from types import ModuleType
+
+from pyrig.dev.utils.packages import get_src_package
+from pyrig.src.modules.class_ import (
+    get_all_cls_from_module,
+    get_all_methods_from_cls,
+)
+from pyrig.src.modules.function import get_all_functions_from_module
+from pyrig.src.modules.inspection import get_qualname_of_obj
+from pyrig.src.modules.module import (
+    create_module,
+    get_isolated_obj_name,
+    get_module_content_as_str,
+    to_path,
+)
+from pyrig.src.modules.package import (
+    walk_package,
+)
+from pyrig.src.testing.convention import (
+    get_test_obj_from_obj,
+    make_test_obj_importpath_from_obj,
+    make_test_obj_name,
+)
+
+
+def make_test_skeletons() -> None:
+    """Create all test files for the project.
+
+    This function orchestrates the test creation process by first setting up the base
+    test structure and then creating test files for all source packages.
+    """
+    create_tests_for_package(get_src_package())
+
+
+def create_tests_for_package(package: ModuleType) -> None:
+    """Create test files for all modules in the source package.
+
+    This function walks through the source package hierarchy and creates corresponding
+    test packages and modules for each package and module found in the source.
+    """
+    for pkg, modules in walk_package(package):
+        create_test_package(pkg)
+        for module in modules:
+            create_test_module(module)
+
+
+def create_test_package(package: ModuleType) -> None:
+    """Create a test package for a source package.
+
+    Args:
+        package: The source package module to create a test package for
+
+    This function creates a test package with the appropriate naming convention
+    if it doesn't already exist.
+
+    """
+    test_package_name = make_test_obj_importpath_from_obj(package)
+    # create package if it doesn't exist
+    create_module(test_package_name, is_package=True)
+
+
+def create_test_module(module: ModuleType) -> None:
+    """Create a test module for a source module.
+
+    Args:
+        module: The source module to create a test module for
+
+    This function:
+    1. Creates a test module with the appropriate naming convention
+    2. Generates the test module content with skeleton test functions
+    3. Writes the content to the test module file
+
+    """
+    test_module_name = make_test_obj_importpath_from_obj(module)
+    test_module = create_module(test_module_name, is_package=False)
+    test_module_path = to_path(test_module, is_package=False)
+    test_module_path.write_text(get_test_module_content(module))
+
+
+def get_test_module_content(module: ModuleType) -> str:
+    """Generate the content for a test module.
+
+    Args:
+        module: The source module to generate test content for
+
+    Returns:
+        The generated test module content as a string
+
+    This function:
+    1. Gets the existing test module content if it exists
+    2. Adds test functions for all functions in the source module
+    3. Adds test classes for all classes in the source module
+
+    """
+    test_module = get_test_obj_from_obj(module)
+    test_module_content = get_module_content_as_str(test_module)
+
+    test_module_content = get_test_functions_content(
+        module, test_module, test_module_content
+    )
+
+    return get_test_classes_content(module, test_module, test_module_content)
+
+
+def get_test_functions_content(
+    module: ModuleType,
+    test_module: ModuleType,
+    test_module_content: str,
+) -> str:
+    """Generate test function content for a module.
+
+    Args:
+        module: The source module containing functions to test
+        test_module: The test module to add function tests to
+        test_module_content: The current content of the test module
+
+    Returns:
+        The updated test module content with function tests added
+
+    This function:
+    1. Identifies all functions in the source module
+    2. Determines which functions don't have corresponding tests
+    3. Generates skeleton test functions for untested functions
+
+    """
+    funcs = get_all_functions_from_module(module)
+    test_functions = get_all_functions_from_module(test_module)
+    supposed_test_funcs_names = [make_test_obj_name(f) for f in funcs]
+
+    test_funcs_names = [get_qualname_of_obj(f) for f in test_functions]
+
+    untested_funcs_names = [
+        f for f in supposed_test_funcs_names if f not in test_funcs_names
+    ]
+
+    for test_func_name in untested_funcs_names:
+        test_module_content += f"""
+
+def {test_func_name}() -> None:
+    \"\"\"Test function.\"\"\"
+    raise {NotImplementedError.__name__}
+"""
+
+    return test_module_content
+
+
+def get_test_classes_content(
+    module: ModuleType,
+    test_module: ModuleType,
+    test_module_content: str,
+) -> str:
+    """Generate test class content for a module.
+
+    Args:
+        module: The source module containing classes to test
+        test_module: The test module to add class tests to
+        test_module_content: The current content of the test module
+
+    Returns:
+        The updated test module content with class tests added
+
+    This function:
+    1. Identifies all classes in the source module
+    2. Determines which classes and methods don't have corresponding tests
+    3. Generates skeleton test classes and methods for untested classes and methods
+    4. Inserts the new test classes into the existing content
+       if the class already exists
+
+    Raises:
+        ValueError: If a test class declaration appears multiple
+                    times in the test module
+
+    """
+    classes = get_all_cls_from_module(module)
+    test_classes = get_all_cls_from_module(test_module)
+
+    class_to_methods = {
+        c: get_all_methods_from_cls(c, exclude_parent_methods=True) for c in classes
+    }
+    test_class_to_methods = {
+        tc: get_all_methods_from_cls(tc, exclude_parent_methods=True)
+        for tc in test_classes
+    }
+
+    supposed_test_class_to_methods_names = {
+        make_test_obj_name(c): [make_test_obj_name(m) for m in ms]
+        for c, ms in class_to_methods.items()
+    }
+    test_class_to_methods_names = {
+        get_isolated_obj_name(tc): [get_isolated_obj_name(tm) for tm in tms]
+        for tc, tms in test_class_to_methods.items()
+    }
+
+    untested_test_class_to_methods_names: dict[str, list[str]] = {}
+    for (
+        test_class_name,
+        supposed_test_methods_names,
+    ) in supposed_test_class_to_methods_names.items():
+        test_methods_names = test_class_to_methods_names.get(test_class_name, [])
+        untested_methods_names = [
+            tmn for tmn in supposed_test_methods_names if tmn not in test_methods_names
+        ]
+        if (
+            not supposed_test_methods_names
+            and test_class_name not in test_class_to_methods_names
+        ):
+            untested_test_class_to_methods_names[test_class_name] = []
+        if untested_methods_names:
+            untested_test_class_to_methods_names[test_class_name] = (
+                untested_methods_names
+            )
+
+    for (
+        test_class_name,
+        untested_methods_names,
+    ) in untested_test_class_to_methods_names.items():
+        test_class_declaration = f"""
+class {test_class_name}:
+    \"\"\"Test class.\"\"\"
+"""
+        test_class_content = test_class_declaration
+        for untested_method_name in untested_methods_names:
+            test_class_content += f"""
+    def {untested_method_name}(self) -> None:
+        \"\"\"Test method.\"\"\"
+        raise {NotImplementedError.__name__}
+"""
+        parts = test_module_content.split(test_class_declaration)
+        expected_parts = 2
+        if len(parts) > expected_parts:
+            msg = f"Found {len(parts)} parts, expected 2"
+            raise ValueError(msg)
+        parts.insert(1, test_class_content)
+        test_module_content = "".join(parts)
+
+    return test_module_content

pyrig/dev/cli/commands/init_project.py

@@ -0,0 +1,160 @@
+"""Project initialization orchestration.
+
+This module provides the main initialization flow for pyrig projects.
+The `init()` function runs a series of setup steps to fully configure
+a new project, including:
+
+1. Writing priority config files (pyproject.toml with dev dependencies)
+2. Installing dependencies with uv
+3. Creating project structure (source and test directories)
+4. Running pre-commit hooks for initial formatting
+5. Running tests to verify setup
+6. Re-installing to activate CLI entry points
+
+The initialization process is idempotent and can be re-run safely.
+
+Example:
+    Run from command line:
+        $ uv run pyrig init
+
+    Or programmatically:
+        >>> from pyrig.src.project.init import init
+        >>> init()
+"""
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+import pyrig
+from pyrig.src.os.os import run_subprocess
+from pyrig.src.project.mgt import PROJECT_MGT, get_pyrig_cli_cmd_args
+from pyrig.src.string import make_name_from_obj
+
+logger = logging.getLogger(__name__)
+
+
+STANDARD_DEV_DEPS: list[str] = ["pyrig-dev"]
+
+
+def adding_dev_dependencies() -> None:
+    """Install development dependencies.
+
+    This installs the dev dependencies listed in pyproject.toml.
+    """
+    run_subprocess([PROJECT_MGT, "add", "--group", "dev", *STANDARD_DEV_DEPS])
+
+
+def creating_priority_config_files() -> None:
+    """Create priority config files.
+
+    This creates the priority config files that are required for
+    the other setup steps.
+    """
+    from pyrig.dev.configs.base.base import ConfigFile  # noqa: PLC0415
+
+    ConfigFile.init_priority_config_files()
+
+
+def syncing_venv() -> None:
+    """Sync the virtual environment.
+
+    This installs the dependencies listed in pyproject.toml.
+    """
+    run_subprocess([PROJECT_MGT, "sync"])
+
+
+def creating_project_root() -> None:
+    """Execute the create-root CLI command via subprocess.
+
+    Invokes `uv run pyrig create-root` to generate all config files
+    and the project directory structure.
+    """
+    from pyrig.dev.cli.subcommands import mkroot  # noqa: PLC0415
+
+    run_subprocess(get_pyrig_cli_cmd_args(mkroot))
+
+
+def creating_test_files() -> None:
+    """Execute the create-tests CLI command via subprocess.
+
+    Invokes `uv run pyrig create-tests` to generate test skeleton
+    files that mirror the source code structure.
+    """
+    from pyrig.dev.cli.subcommands import mktests  # noqa: PLC0415
+
+    run_subprocess(get_pyrig_cli_cmd_args(mktests))
+
+
+def running_pre_commit_hooks() -> None:
+    """Run all pre-commit hooks.
+
+    This runs all pre-commit hooks to ensure the codebase is
+    in a clean, linted, and formatted state.
+    """
+    from pyrig.dev.configs.git.pre_commit import (  # noqa: PLC0415
+        PreCommitConfigConfigFile,
+    )
+
+    PreCommitConfigConfigFile.run_hooks(add_before_commit=True)
+
+
+def running_tests() -> None:
+    """Run the test suite.
+
+    This executes the test suite to verify that everything is
+    working correctly after initialization.
+    """
+    from pyrig.dev.configs.testing.conftest import ConftestConfigFile  # noqa: PLC0415
+
+    ConftestConfigFile.run_tests()
+
+
+def committing_initial_changes() -> None:
+    """Commit all initial changes.
+
+    This commits all changes made during initialization in a single commit.
+    """
+    # changes were added by the run pre-commit hooks step
+    run_subprocess(
+        ["git", "commit", "--no-verify", "-m", f"{pyrig.__name__}: Initial commit"]
+    )
+
+
+SETUP_STEPS: list[Callable[..., Any]] = [
+    adding_dev_dependencies,
+    syncing_venv,
+    creating_priority_config_files,
+    syncing_venv,
+    creating_project_root,
+    creating_test_files,
+    running_pre_commit_hooks,
+    running_tests,
+    committing_initial_changes,
+]
+
+
+def init_project() -> None:
+    """Initialize a pyrig project by running all setup steps.
+
+    Executes each step in `SETUP_STEPS` sequentially, logging progress.
+    This is the main entry point for the `pyrig init` command.
+
+    The steps include:
+        1. Write priority config files (pyproject.toml)
+        2. Install dependencies
+        3. Update dependencies to latest
+        4. Create project structure
+        5. Generate test skeletons
+        6. Run pre-commit hooks
+        7. Run tests
+        8. Re-install to activate CLI
+    """
+    # for init set log level to info
+    logging.basicConfig(level=logging.INFO)
+
+    for step in SETUP_STEPS:
+        step_name = make_name_from_obj(step, join_on=" ")
+        logger.info(step_name)
+        step()
+    logger.info("Setup complete!")

pyrig/dev/cli/commands/make_inits.py

@@ -0,0 +1,27 @@
+"""A func that creates __init__.py files for all packages and modules."""
+
+from pyrig.dev.utils.packages import find_packages
+from pyrig.src.modules.module import make_init_module, to_path
+from pyrig.src.modules.package import DOCS_DIR_NAME
+
+
+def get_namespace_packages() -> list[str]:
+    """Get all namespace packages."""
+    packages = find_packages(depth=None)
+    namespace_packages = find_packages(depth=None, include_namespace_packages=True)
+    namespace_packages = [
+        p for p in namespace_packages if not p.startswith(DOCS_DIR_NAME)
+    ]
+    return list(set(namespace_packages) - set(packages))
+
+
+def make_init_files() -> None:
+    """Create __init__.py files for all packages and modules.
+
+    Will not overwrite existing files.
+    """
+    any_namespace_packages = get_namespace_packages()
+    if any_namespace_packages:
+        # make init files for all namespace packages
+        for package in any_namespace_packages:
+            make_init_module(to_path(package, is_package=True))

pyrig/dev/cli/commands/protect_repo.py

@@ -0,0 +1,145 @@
+"""Repository protection and security configuration.
+
+This module provides functions to configure secure repository settings and
+branch protection rulesets on GitHub. It implements pyrig's opinionated
+security defaults, including required reviews, status checks, and merge
+restrictions.
+
+The protection rules enforce:
+    - Required pull request reviews with code owner approval
+    - Required status checks (health check workflow must pass)
+    - Linear commit history (no merge commits)
+    - Signed commits
+    - No force pushes or deletions
+
+Example:
+    >>> from pyrig.src.git.github.repo.protect import protect_repository
+    >>> protect_repository()  # Applies all protection rules
+"""
+
+from typing import Any
+
+from pyrig.dev.configs.pyproject import PyprojectConfigFile
+from pyrig.dev.utils.git import (
+    DEFAULT_BRANCH,
+    DEFAULT_RULESET_NAME,
+    create_or_update_ruleset,
+    get_github_repo_token,
+    get_repo,
+    get_rules_payload,
+)
+from pyrig.src.git.git import (
+    get_repo_owner_and_name_from_git,
+)
+
+
+def protect_repository() -> None:
+    """Apply all security protections to the repository.
+
+    Configures both repository-level settings and branch protection
+    rulesets. This is the main entry point for securing a repository.
+    """
+    set_secure_repo_settings()
+    create_or_update_default_branch_ruleset()
+
+
+def set_secure_repo_settings() -> None:
+    """Configure repository-level settings for security and consistency.
+
+    Sets the following repository settings:
+        - Description from pyproject.toml
+        - Default branch to 'main'
+        - Delete branches on merge
+        - Allow update branch button
+        - Disable merge commits (squash and rebase only)
+    """
+    owner, repo_name = get_repo_owner_and_name_from_git()
+    token = get_github_repo_token()
+    repo = get_repo(token, owner, repo_name)
+
+    toml_description = PyprojectConfigFile.get_project_description()
+
+    repo.edit(
+        name=repo_name,
+        description=toml_description,
+        default_branch=DEFAULT_BRANCH,
+        delete_branch_on_merge=True,
+        allow_update_branch=True,
+        allow_merge_commit=False,
+        allow_rebase_merge=True,
+        allow_squash_merge=True,
+    )
+
+
+def create_or_update_default_branch_ruleset() -> None:
+    """Create or update the default branch protection ruleset.
+
+    Applies pyrig's standard protection rules to the default branch (main).
+    If a ruleset with the same name already exists, it is updated.
+    """
+    create_or_update_ruleset(
+        **get_default_ruleset_params(),
+    )
+
+
+def get_default_ruleset_params() -> dict[str, Any]:
+    """Build the parameter dictionary for the default branch ruleset.
+
+    Constructs the complete ruleset configuration including:
+        - Branch targeting (default branch only)
+        - Bypass permissions for repository admins
+        - All protection rules (reviews, status checks, etc.)
+
+    Returns:
+        A dictionary of parameters suitable for `create_or_update_ruleset()`.
+    """
+    from pyrig.dev.configs.workflows.health_check import (  # noqa: PLC0415
+        HealthCheckWorkflow,  # avoid circular import
+    )
+
+    owner, repo_name = get_repo_owner_and_name_from_git()
+    token = get_github_repo_token()
+
+    rules = get_rules_payload(
+        deletion={},
+        non_fast_forward={},
+        creation={},
+        update={},
+        pull_request={
+            "required_approving_review_count": 1,
+            "dismiss_stale_reviews_on_push": True,
+            "require_code_owner_review": True,
+            "require_last_push_approval": True,
+            "required_review_thread_resolution": True,
+            "allowed_merge_methods": ["squash", "rebase"],
+        },
+        required_linear_history={},
+        required_signatures={},
+        required_status_checks={
+            "strict_required_status_checks_policy": True,
+            "do_not_enforce_on_create": False,
+            "required_status_checks": [
+                {
+                    "context": HealthCheckWorkflow.get_filename(),
+                }
+            ],
+        },
+    )
+
+    return {
+        "owner": owner,
+        "token": token,
+        "repo_name": repo_name,
+        "ruleset_name": DEFAULT_RULESET_NAME,
+        "enforcement": "active",
+        "bypass_actors": [
+            {
+                "actor_id": 5,
+                "actor_type": "RepositoryRole",
+                "bypass_mode": "always",
+            }
+        ],
+        "target": "branch",
+        "conditions": {"ref_name": {"include": ["~DEFAULT_BRANCH"], "exclude": []}},
+        "rules": rules,
+    }

pyrig/dev/cli/shared_subcommands.py

@@ -0,0 +1,20 @@
+"""Shared commands for the CLI.
+
+This module provides shared CLI commands that can be used by multiple
+packages in a multi-package architecture. These commands are automatically
+discovered and added to the CLI by pyrig.
+Example is version command that is available in all packages.
+uv run my-awesome-project version will return my-awesome-project version 0.1.0
+"""
+
+from importlib.metadata import version as get_version
+
+import typer
+
+from pyrig.dev.utils.cli import get_project_name_from_argv
+
+
+def version() -> None:
+    """Display the version information."""
+    project_name = get_project_name_from_argv()
+    typer.echo(f"{project_name} version {get_version(project_name)}")

pyrig/dev/cli/subcommands.py

@@ -0,0 +1,73 @@
+"""Subcommands for the CLI.
+
+They will be automatically imported and added to the CLI
+IMPORTANT: All funcs in this file will be added as subcommands.
+So best to define the logic elsewhere and just call it here in a wrapper.
+"""
+
+
+def mkroot() -> None:
+    """Creates the root of the project.
+
+    This inits all ConfigFiles and creates __init__.py files for the src
+    and tests package where they are missing. It does not overwrite any
+    existing files.
+    """
+    from pyrig.dev.cli.commands.create_root import make_project_root  # noqa: PLC0415
+
+    make_project_root()
+
+
+def mktests() -> None:
+    """Create all test files for the project.
+
+    This generates test skeletons for all functions and classes in the src
+    package. It does not overwrite any existing tests.
+    Tests are also automatically generated when missing by running pytest.
+    """
+    from pyrig.dev.cli.commands.create_tests import make_test_skeletons  # noqa: PLC0415
+
+    make_test_skeletons()
+
+
+def mkinits() -> None:
+    """Create all __init__.py files for the project.
+
+    This creates __init__.py files for all packages and modules
+    that are missing them. It does not overwrite any existing files.
+    """
+    from pyrig.dev.cli.commands.make_inits import make_init_files  # noqa: PLC0415
+
+    make_init_files()
+
+
+def init() -> None:
+    """Set up the project.
+
+    This is the setup command when you created the project from scratch.
+    It will init all config files, create the root, create tests, and run
+    all pre-commit hooks and tests.
+    """
+    from pyrig.dev.cli.commands.init_project import init_project  # noqa: PLC0415
+
+    init_project()
+
+
+def build() -> None:
+    """Build all artifacts.
+
+    Invokes every subclass of Builder in the builder package.
+    """
+    from pyrig.dev.cli.commands.build_artifacts import build_artifacts  # noqa: PLC0415
+
+    build_artifacts()
+
+
+def protect_repo() -> None:
+    """Protect the repository.
+
+    This will set secure repo settings and add a branch protection rulesets.
+    """
+    from pyrig.dev.cli.commands.protect_repo import protect_repository  # noqa: PLC0415
+
+    protect_repository()

pyrig/dev/configs/__init__.py

@@ -0,0 +1 @@
+"""__init__ module."""

pyrig/dev/configs/base/__init__.py

@@ -0,0 +1,5 @@
+"""Base classes for configuration file management.
+
+This package provides the abstract ConfigFile base class and format-specific
+subclasses (YAML, TOML, Python, Text) for managing project configuration.
+"""