rhiza 0.9.1__py3-none-any.whl → 0.10.1__py3-none-any.whl

rhiza/bundle_resolver.py

@@ -0,0 +1,78 @@
+"""Bundle resolution logic for template configuration.
+
+This module provides functions to load and resolve bundle configurations
+from the template repository's template_bundles.yml file.
+"""
+
+from pathlib import Path
+
+from rhiza.models import RhizaBundles, RhizaTemplate
+
+
+def load_bundles_from_clone(tmp_dir: Path) -> RhizaBundles | None:
+    """Load .rhiza/template_bundles.yml from cloned template repo.
+
+    Args:
+        tmp_dir: Path to the cloned template repository.
+
+    Returns:
+        RhizaBundles if template_bundles.yml exists, None otherwise.
+
+    Raises:
+        yaml.YAMLError: If template_bundles.yml is malformed.
+        ValueError: If template_bundles.yml is invalid.
+    """
+    bundles_file = tmp_dir / ".rhiza" / "template_bundles.yml"
+    if not bundles_file.exists():
+        return None
+    return RhizaBundles.from_yaml(bundles_file)
+
+
+def resolve_include_paths(
+    template: RhizaTemplate,
+    bundles_config: RhizaBundles | None,
+) -> list[str]:
+    """Resolve template configuration to file paths.
+
+    Supports:
+    - Template-based mode (templates field)
+    - Path-based mode (include field)
+    - Hybrid mode (both templates and include)
+
+    Args:
+        template: The template configuration.
+        bundles_config: The loaded bundles configuration, or None if not available.
+
+    Returns:
+        List of file paths to materialize.
+
+    Raises:
+        ValueError: If configuration is invalid or bundles.yml is missing.
+    """
+    paths = []
+
+    # Resolve templates to paths if specified
+    if template.templates:
+        if not bundles_config:
+            msg = "Template uses templates but template_bundles.yml not found in template repository"
+            raise ValueError(msg)
+        paths.extend(bundles_config.resolve_to_paths(template.templates))
+
+    # Add include paths if specified
+    if template.include:
+        paths.extend(template.include)
+
+    # At least one must be specified
+    if not paths:
+        msg = "Template configuration must specify either 'templates' or 'include'"
+        raise ValueError(msg)
+
+    # Deduplicate while preserving order
+    seen = set()
+    deduplicated = []
+    for path in paths:
+        if path not in seen:
+            deduplicated.append(path)
+            seen.add(path)
+
+    return deduplicated

rhiza/commands/init.py

@@ -84,8 +84,24 @@ def _prompt_git_host() -> str:
     return str(git_host)
 
 
+def _get_default_templates_for_host(git_host: str) -> list[str]:
+    """Get default templates based on git hosting platform.
+
+    Args:
+        git_host: Git hosting platform.
+
+    Returns:
+        List of template names.
+    """
+    common = ["core", "tests", "docs"]
+    if git_host == "gitlab":
+        return [*common, "gitlab"]
+    else:
+        return [*common, "github"]
+
+
 def _get_include_paths_for_host(git_host: str) -> list[str]:
-    """Get include paths based on git hosting platform.
+    """Get include paths based on git hosting platform (legacy, path-based).
 
     Args:
         git_host: Git hosting platform.
@@ -129,6 +145,7 @@ def _create_template_file(
     git_host: str,
     template_repository: str | None = None,
     template_branch: str | None = None,
+    use_templates: bool = True,
 ) -> None:
     """Create default template.yml file.
 
@@ -137,6 +154,7 @@ def _create_template_file(
         git_host: Git hosting platform.
         template_repository: Custom template repository (format: owner/repo).
         template_branch: Custom template branch.
+        use_templates: Use template-based configuration if True, path-based if False.
     """
     rhiza_dir = target / ".rhiza"
     template_file = rhiza_dir / "template.yml"
@@ -147,8 +165,6 @@ def _create_template_file(
     logger.info("Creating default .rhiza/template.yml")
     logger.debug("Using default template configuration")
 
-    include_paths = _get_include_paths_for_host(git_host)
-
     # Use custom template repository/branch if provided, otherwise use defaults
     repo = template_repository or "jebel-quant/rhiza"
     branch = template_branch or "main"
@@ -159,11 +175,22 @@ def _create_template_file(
     if template_branch:
         logger.info(f"Using custom template branch: {branch}")
 
-    default_template = RhizaTemplate(
-        template_repository=repo,
-        template_branch=branch,
-        include=include_paths,
-    )
+    if use_templates:
+        templates = _get_default_templates_for_host(git_host)
+        logger.info(f"Using template-based configuration with templates: {', '.join(templates)}")
+        default_template = RhizaTemplate(
+            template_repository=repo,
+            template_branch=branch,
+            templates=templates,
+        )
+    else:
+        include_paths = _get_include_paths_for_host(git_host)
+        logger.info("Using path-based configuration")
+        default_template = RhizaTemplate(
+            template_repository=repo,
+            template_branch=branch,
+            include=include_paths,
+        )
 
     logger.debug(f"Writing default template to: {template_file}")
     default_template.to_yaml(template_file)

rhiza/commands/materialize.py

@@ -15,6 +15,7 @@ from pathlib import Path
 
 from loguru import logger
 
+from rhiza.bundle_resolver import load_bundles_from_clone, resolve_include_paths
 from rhiza.commands.validate import validate
 from rhiza.models import RhizaTemplate
 from rhiza.subprocess_utils import get_git_executable
@@ -117,19 +118,28 @@ def _validate_and_load_template(target: Path, branch: str) -> tuple[RhizaTemplat
         logger.error("template-repository is not configured in template.yml")
         raise RuntimeError("template-repository is required")  # noqa: TRY003
     rhiza_branch = template.template_branch or branch
-    include_paths = template.include
     excluded_paths = template.exclude
 
-    # Validate that we have paths to include
-    if not include_paths:
-        logger.error("No include paths found in template.yml")
-        logger.error("Add at least one path to the 'include' list in template.yml")
-        raise RuntimeError("No include paths found in template.yml")  # noqa: TRY003
+    # Note: We'll resolve templates to paths after cloning the template repo,
+    # since we need access to template_bundles.yml from the template
+    include_paths = template.include
 
-    # Log the paths we'll be including
-    logger.info("Include paths:")
-    for p in include_paths:
-        logger.info(f"  - {p}")
+    # Validate that we have either templates or include paths
+    if not template.templates and not include_paths:
+        logger.error("No templates or include paths found in template.yml")
+        logger.error("Add either 'templates' or 'include' list in template.yml")
+        raise RuntimeError("No templates or include paths found in template.yml")  # noqa: TRY003
+
+    # Log what we'll be using
+    if template.templates:
+        logger.info("Templates:")
+        for t in template.templates:
+            logger.info(f"  - {t}")
+
+    if include_paths:
+        logger.info("Include paths:")
+        for p in include_paths:
+            logger.info(f"  - {p}")
 
     if excluded_paths:
         logger.info("Exclude paths:")
@@ -165,6 +175,37 @@ def _construct_git_url(rhiza_repo: str, rhiza_host: str) -> str:
     return git_url
 
 
+def _update_sparse_checkout(
+    tmp_dir: Path,
+    include_paths: list[str],
+    git_executable: str,
+    git_env: dict[str, str],
+) -> None:
+    """Update sparse checkout paths in an already-cloned repository.
+
+    Args:
+        tmp_dir: Temporary directory with cloned repository.
+        include_paths: Paths to include in sparse checkout.
+        git_executable: Path to git executable.
+        git_env: Environment variables for git commands.
+    """
+    try:
+        logger.debug(f"Updating sparse checkout paths: {include_paths}")
+        subprocess.run(  # nosec B603
+            [git_executable, "sparse-checkout", "set", "--skip-checks", *include_paths],
+            cwd=tmp_dir,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=git_env,
+        )
+        logger.debug("Sparse checkout paths updated")
+    except subprocess.CalledProcessError as e:
+        logger.error("Failed to update sparse checkout paths")
+        _log_git_stderr_errors(e.stderr)
+        sys.exit(1)
+
+
 def _clone_template_repository(
     tmp_dir: Path,
     git_url: str,
@@ -179,7 +220,7 @@ def _clone_template_repository(
         tmp_dir: Temporary directory for cloning.
         git_url: Git repository URL.
         rhiza_branch: Branch to clone.
-        include_paths: Paths to include in sparse checkout.
+        include_paths: Initial paths to include in sparse checkout.
         git_executable: Path to git executable.
         git_env: Environment variables for git commands.
     """
@@ -504,7 +545,25 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
     logger.debug(f"Temporary directory: {tmp_dir}")
 
     try:
-        _clone_template_repository(tmp_dir, git_url, rhiza_branch, include_paths, git_executable, git_env)
+        # Clone with initial minimal checkout to load template_bundles.yml if needed
+        initial_paths = [".rhiza"] if template.templates else include_paths
+        _clone_template_repository(tmp_dir, git_url, rhiza_branch, initial_paths, git_executable, git_env)
+
+        # Load template_bundles.yml and resolve templates to paths if using template mode
+        if template.templates:
+            logger.info("Resolving templates to file paths...")
+            try:
+                bundles_config = load_bundles_from_clone(tmp_dir)
+                resolved_paths = resolve_include_paths(template, bundles_config)
+                logger.info(f"Resolved {len(template.templates)} template(s) to {len(resolved_paths)} path(s)")
+                logger.debug(f"Resolved paths: {resolved_paths}")
+                # Update sparse checkout with resolved paths
+                _update_sparse_checkout(tmp_dir, resolved_paths, git_executable, git_env)
+                include_paths = resolved_paths
+            except ValueError as e:
+                logger.error(f"Failed to resolve templates: {e}")
+                sys.exit(1)
+
         materialized_files = _copy_files_to_target(tmp_dir, target, include_paths, excluded_paths, force)
     finally:
         logger.debug(f"Cleaning up temporary directory: {tmp_dir}")

rhiza/commands/validate.py

@@ -126,6 +126,78 @@ def _parse_yaml_file(template_file: Path) -> tuple[bool, dict[str, Any] | None]:
     return True, config
 
 
+def _validate_configuration_mode(config: dict[str, Any]) -> bool:
+    """Validate that at least one of templates or include is specified.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        True if configuration mode is valid, False otherwise.
+    """
+    logger.debug("Validating configuration mode")
+    has_templates = "templates" in config and config["templates"]
+    has_include = "include" in config and config["include"]
+
+    # Error if old "bundles" field is used
+    if "bundles" in config:
+        logger.error("Field 'bundles' has been renamed to 'templates'")
+        logger.error("Update your .rhiza/template.yml:")
+        logger.error("  bundles: [...]  →  templates: [...]")
+        return False
+
+    # Require at least one of templates or include
+    if not has_templates and not has_include:
+        logger.error("Must specify at least one of 'templates' or 'include' in template.yml")
+        logger.error("Options:")
+        logger.error("  • Template-based: templates: [core, tests, github]")
+        logger.error("  • Path-based: include: [.rhiza, .github, ...]")
+        logger.error("  • Hybrid: specify both templates and include")
+        return False
+
+    # Log what mode is being used
+    if has_templates and has_include:
+        logger.success("Using hybrid mode (templates + include)")
+    elif has_templates:
+        logger.success("Using template-based mode")
+    else:
+        logger.success("Using path-based mode")
+
+    return True
+
+
+def _validate_templates(config: dict[str, Any]) -> bool:
+    """Validate templates field if present.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        True if templates field is valid, False otherwise.
+    """
+    logger.debug("Validating templates field")
+    if "templates" not in config:
+        return True
+
+    templates = config["templates"]
+    if not isinstance(templates, list):
+        logger.error(f"templates must be a list, got {type(templates).__name__}")
+        logger.error("Example: templates: [core, tests, github]")
+        return False
+    elif len(templates) == 0:
+        logger.error("templates list cannot be empty")
+        logger.error("Add at least one template to materialize")
+        return False
+    else:
+        logger.success(f"templates list has {len(templates)} template(s)")
+        for template in templates:
+            if not isinstance(template, str):
+                logger.warning(f"template name should be a string, got {type(template).__name__}: {template}")
+            else:
+                logger.info(f"  - {template}")
+        return True
+
+
 def _validate_required_fields(config: dict[str, Any]) -> bool:
     """Validate required fields exist and have correct types.
 
@@ -136,9 +208,10 @@ def _validate_required_fields(config: dict[str, Any]) -> bool:
         True if all validations pass, False otherwise.
     """
     logger.debug("Validating required fields")
+    # template-repository is required
+    # include or bundles is required (validated separately)
     required_fields = {
         "template-repository": str,
-        "include": list,
     }
 
     validation_passed = True
@@ -305,6 +378,10 @@ def validate(target: Path) -> bool:
     if not success or config is None:
         return False
 
+    # Validate configuration mode (templates OR include)
+    if not _validate_configuration_mode(config):
+        return False
+
     # Validate required fields
     validation_passed = _validate_required_fields(config)
 
@@ -312,8 +389,15 @@ def validate(target: Path) -> bool:
     if not _validate_repository_format(config):
         validation_passed = False
 
-    if not _validate_include_paths(config):
-        validation_passed = False
+    # Validate templates if present
+    if config.get("templates"):
+        if not _validate_templates(config):
+            validation_passed = False
+
+    # Validate include if present
+    if config.get("include"):
+        if not _validate_include_paths(config):
+            validation_passed = False
 
     # Validate optional fields
     _validate_optional_fields(config)

rhiza/models.py

@@ -11,6 +11,12 @@ from typing import Any
 
 import yaml  # type: ignore[import-untyped]
 
+__all__ = [
+    "BundleDefinition",
+    "RhizaBundles",
+    "RhizaTemplate",
+]
+
 
 def _normalize_to_list(value: str | list[str] | None) -> list[str]:
     r"""Convert a value to a list of strings.
@@ -56,6 +62,162 @@ def _normalize_to_list(value: str | list[str] | None) -> list[str]:
     return []
 
 
+@dataclass
+class BundleDefinition:
+    """Represents a single bundle from template_bundles.yml.
+
+    Attributes:
+        name: The bundle identifier (e.g., "core", "tests", "github").
+        description: Human-readable description of the bundle.
+        files: List of file paths included in this bundle.
+        workflows: List of workflow file paths included in this bundle.
+        depends_on: List of bundle names that this bundle depends on.
+    """
+
+    name: str
+    description: str
+    files: list[str] = field(default_factory=list)
+    workflows: list[str] = field(default_factory=list)
+    depends_on: list[str] = field(default_factory=list)
+
+    def all_paths(self) -> list[str]:
+        """Return combined files and workflows."""
+        return self.files + self.workflows
+
+
+@dataclass
+class RhizaBundles:
+    """Represents the structure of template_bundles.yml.
+
+    Attributes:
+        version: Version string of the bundles configuration format.
+        bundles: Dictionary mapping bundle names to their definitions.
+    """
+
+    version: str
+    bundles: dict[str, BundleDefinition] = field(default_factory=dict)
+
+    @classmethod
+    def from_yaml(cls, file_path: Path) -> "RhizaBundles":
+        """Load RhizaBundles from a YAML file.
+
+        Args:
+            file_path: Path to the template_bundles.yml file.
+
+        Returns:
+            The loaded bundles configuration.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+            yaml.YAMLError: If the YAML is malformed.
+            ValueError: If the file is invalid or missing required fields.
+            TypeError: If bundle data has invalid types.
+        """
+        with open(file_path) as f:
+            config = yaml.safe_load(f)
+
+        if not config:
+            raise ValueError("Bundles file is empty")  # noqa: TRY003
+
+        version = config.get("version")
+        if not version:
+            raise ValueError("Bundles file missing required field: version")  # noqa: TRY003
+
+        bundles_config = config.get("bundles", {})
+        if not isinstance(bundles_config, dict):
+            msg = "Bundles must be a dictionary"
+            raise TypeError(msg)
+
+        bundles: dict[str, BundleDefinition] = {}
+        for bundle_name, bundle_data in bundles_config.items():
+            if not isinstance(bundle_data, dict):
+                msg = f"Bundle '{bundle_name}' must be a dictionary"
+                raise TypeError(msg)
+
+            files = _normalize_to_list(bundle_data.get("files"))
+            workflows = _normalize_to_list(bundle_data.get("workflows"))
+            depends_on = _normalize_to_list(bundle_data.get("depends-on"))
+
+            bundles[bundle_name] = BundleDefinition(
+                name=bundle_name,
+                description=bundle_data.get("description", ""),
+                files=files,
+                workflows=workflows,
+                depends_on=depends_on,
+            )
+
+        return cls(version=version, bundles=bundles)
+
+    def resolve_dependencies(self, bundle_names: list[str]) -> list[str]:
+        """Resolve bundle dependencies using topological sort.
+
+        Args:
+            bundle_names: List of bundle names to resolve.
+
+        Returns:
+            Ordered list of bundle names with dependencies first, no duplicates.
+
+        Raises:
+            ValueError: If a bundle doesn't exist or circular dependency detected.
+        """
+        # Validate all bundles exist
+        for name in bundle_names:
+            if name not in self.bundles:
+                raise ValueError(f"Bundle '{name}' not found in template_bundles.yml")  # noqa: TRY003
+
+        resolved: list[str] = []
+        visiting: set[str] = set()
+        visited: set[str] = set()
+
+        def visit(bundle_name: str) -> None:
+            if bundle_name in visited:
+                return
+            if bundle_name in visiting:
+                raise ValueError(f"Circular dependency detected involving '{bundle_name}'")  # noqa: TRY003
+
+            visiting.add(bundle_name)
+            bundle = self.bundles[bundle_name]
+
+            for dep in bundle.depends_on:
+                if dep not in self.bundles:
+                    raise ValueError(f"Bundle '{bundle_name}' depends on unknown bundle '{dep}'")  # noqa: TRY003
+                visit(dep)
+
+            visiting.remove(bundle_name)
+            visited.add(bundle_name)
+            resolved.append(bundle_name)
+
+        for name in bundle_names:
+            visit(name)
+
+        return resolved
+
+    def resolve_to_paths(self, bundle_names: list[str]) -> list[str]:
+        """Convert bundle names to deduplicated file paths.
+
+        Args:
+            bundle_names: List of bundle names to resolve.
+
+        Returns:
+            Deduplicated list of file paths from all bundles and their dependencies.
+
+        Raises:
+            ValueError: If a bundle doesn't exist or circular dependency detected.
+        """
+        resolved_bundles = self.resolve_dependencies(bundle_names)
+        paths: list[str] = []
+        seen: set[str] = set()
+
+        for bundle_name in resolved_bundles:
+            bundle = self.bundles[bundle_name]
+            for path in bundle.all_paths():
+                if path not in seen:
+                    paths.append(path)
+                    seen.add(path)
+
+        return paths
+
+
 @dataclass
 class RhizaTemplate:
     """Represents the structure of .rhiza/template.yml.
@@ -67,8 +229,10 @@ class RhizaTemplate:
             Can be None if not specified in the template file (defaults to "main" when creating).
         template_host: The git hosting platform ("github" or "gitlab").
             Defaults to "github" if not specified in the template file.
-        include: List of paths to include from the template repository.
+        include: List of paths to include from the template repository (path-based mode).
         exclude: List of paths to exclude from the template repository (default: empty list).
+        templates: List of template names to include (template-based mode).
+            Can be used together with include to merge paths.
     """
 
     template_repository: str | None = None
@@ -76,6 +240,7 @@ class RhizaTemplate:
     template_host: str = "github"
     include: list[str] = field(default_factory=list)
     exclude: list[str] = field(default_factory=list)
+    templates: list[str] = field(default_factory=list)
 
     @classmethod
     def from_yaml(cls, file_path: Path) -> "RhizaTemplate":
@@ -104,6 +269,7 @@ class RhizaTemplate:
             template_host=config.get("template-host", "github"),
             include=_normalize_to_list(config.get("include")),
             exclude=_normalize_to_list(config.get("exclude")),
+            templates=_normalize_to_list(config.get("templates")),
         )
 
     def to_yaml(self, file_path: Path) -> None:
@@ -130,8 +296,13 @@ class RhizaTemplate:
         if self.template_host and self.template_host != "github":
             config["template-host"] = self.template_host
 
-        # Include is always present as it's a required field for the config to be useful
-        config["include"] = self.include
+        # Write templates if present
+        if self.templates:
+            config["templates"] = self.templates
+
+        # Write include if present (can coexist with templates)
+        if self.include:
+            config["include"] = self.include
 
         # Only include exclude if it's not empty
         if self.exclude:

{rhiza-0.9.1.dist-info → rhiza-0.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhiza
-Version: 0.9.1
+Version: 0.10.1
 Summary: Reusable configuration templates for modern Python projects
 Project-URL: Homepage, https://github.com/jebel-quant/rhiza-cli
 Project-URL: Repository, https://github.com/jebel-quant/rhiza-cli
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-# <img src="https://raw.githubusercontent.com/Jebel-Quant/rhiza/main/assets/rhiza-logo.svg" alt="Rhiza Logo" width="30" style="vertical-align: middle;"> rhiza-cli
+# <img src="https://raw.githubusercontent.com/Jebel-Quant/rhiza/main/.rhiza/assets/rhiza-logo.svg" alt="Rhiza Logo" width="30" style="vertical-align: middle;"> rhiza-cli
 ![Synced with Rhiza](https://img.shields.io/badge/synced%20with-rhiza-2FA4A9?color=2FA4A9)
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)

{rhiza-0.9.1.dist-info → rhiza-0.10.1.dist-info}/RECORD

@@ -1,21 +1,22 @@
 rhiza/__init__.py,sha256=4-Dy7AKbJneQNBfv30WhSsUin4y-g4Yp4veO6-YdjVg,1926
 rhiza/__main__.py,sha256=GlTahVC8F6fKEpMw_nZyhp4PB-fyC9UQ_RjTZcpD9P4,837
+rhiza/bundle_resolver.py,sha256=ErIgZeoxhjL81aXPxMggqIi7-AD6HicPkOBMahVPN1o,2293
 rhiza/cli.py,sha256=y2qzFbrd29-j5OXslM96hZB9vDLvLv5FBnR9SnDdQWE,10613
-rhiza/models.py,sha256=39oWJM13D_5FupCFUguiB8VMe5Mk4O8CPEpjPftNUjs,5039
+rhiza/models.py,sha256=-gVzDQNl_-zWKvdGqx4gL3DSFjbbBHuKAUtyvBMJ13o,10839
 rhiza/subprocess_utils.py,sha256=Pr5TysIKP76hc64fmqhTd6msMGn5DU43hOSR_v_GFb8,745
 rhiza/_templates/basic/__init__.py.jinja2,sha256=gs8qN4LAKcdFd6iO9gZVLuVetODmZP_TGuEjWrbinC0,27
 rhiza/_templates/basic/main.py.jinja2,sha256=uTCahxf9Bftao1IghHue4cSZ9YzBYmBEXeIhEmK9UXQ,362
 rhiza/_templates/basic/pyproject.toml.jinja2,sha256=Mizpnnd_kFQd-pCWOxG-KWhvg4_ZhZaQppTt2pz0WOc,695
 rhiza/commands/__init__.py,sha256=DV1nlcXxeeHXmHobVcfOsGeiZBZ55Xz1mud073AXDGc,1839
-rhiza/commands/init.py,sha256=4pjNblghF8zFxKJUfw_wA5Ne_xKbovHR7iPxOPQ8zHg,9798
-rhiza/commands/materialize.py,sha256=f6B6luANF089Wn4WzXq7V6oGeFdV6UiMY_-JxUyNfwQ,19741
+rhiza/commands/init.py,sha256=fD_Nc-EtNo9Fb0PVRLkN2RYMteVv_BUTinAa2jz0_Q4,10745
+rhiza/commands/materialize.py,sha256=ZKliQu-_L89Y5j_tq2KF5sKmgUgzngcm70MRmKwuVf8,22256
 rhiza/commands/migrate.py,sha256=A5t4nw7CrdtILCwuSoAqtmM0LpMK8KmX87gzlNgi7fQ,7522
 rhiza/commands/summarise.py,sha256=vgc7M3dwuGjUuVs3XKQr2_g3qURnQH_R3eFoSSrnOro,11758
 rhiza/commands/uninstall.py,sha256=6oO7kdv11Bq4JXjrBg9rsFtoRgttQ4m30zGr6NhZrkQ,7479
-rhiza/commands/validate.py,sha256=z3ePMPYm2nYOYSxbVNWVU4cz52MNjCIz8ChAMnCsIes,10906
+rhiza/commands/validate.py,sha256=_yGx7ARk5K4hqfwzPpJg_7JoG4un0lqHJYJU-4cmYvI,13948
 rhiza/commands/welcome.py,sha256=VknKaUh-bD6dM-zcD1eP4H-D_npyezpfF3bTSl_0Dio,2383
-rhiza-0.9.1.dist-info/METADATA,sha256=5gMfSF0HgsGGEpE2IlblyWJwXxdzjzAZt6-rzExvkQk,26298
-rhiza-0.9.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-rhiza-0.9.1.dist-info/entry_points.txt,sha256=NAwZUpbXvfKv50a_Qq-PxMHl3lcjAyZO63IBeuUNgfY,45
-rhiza-0.9.1.dist-info/licenses/LICENSE,sha256=4m5X7LhqX-6D0Ks79Ys8CLpmza8cxDG34g4S9XSNAGY,1077
-rhiza-0.9.1.dist-info/RECORD,,
+rhiza-0.10.1.dist-info/METADATA,sha256=OGXKAYAT45X6_JOJZ53fMWlMRAO_sz5vrQgoF3o8GCE,26306
+rhiza-0.10.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rhiza-0.10.1.dist-info/entry_points.txt,sha256=NAwZUpbXvfKv50a_Qq-PxMHl3lcjAyZO63IBeuUNgfY,45
+rhiza-0.10.1.dist-info/licenses/LICENSE,sha256=4m5X7LhqX-6D0Ks79Ys8CLpmza8cxDG34g4S9XSNAGY,1077
+rhiza-0.10.1.dist-info/RECORD,,