rdetoolkit 1.5.1__cp314-cp314-win_amd64.whl → 1.5.2__cp314-cp314-win_amd64.whl

rdetoolkit/__init__.py

@@ -1,9 +1,21 @@
 from __future__ import annotations
 
+import sys
+import warnings
+
+# Python 3.9 deprecation warning (Issue #360)
+if sys.version_info < (3, 10):
+    warnings.warn(
+        "Python 3.9 support is deprecated and will be removed in rdetoolkit v2.0. "
+        "Please upgrade to Python 3.10 or later.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
 from importlib import import_module
 from typing import Any
 
-__version__ = "1.5.1"
+__version__ = "1.5.2"
 
 _LAZY_ATTRS: dict[str, tuple[str, str]] = {
     "DirectoryOps": ("rdetoolkit.core", "DirectoryOps"),
@@ -26,6 +38,9 @@ _LAZY_MODULES: dict[str, str] = {
     "rde2util": "rdetoolkit.rde2util",
     "rdelogger": "rdetoolkit.rdelogger",
     "workflows": "rdetoolkit.workflows",
+    "processing": "rdetoolkit.processing",
+    "storage": "rdetoolkit.storage",
+    "traceback": "rdetoolkit.traceback",
     "config": "rdetoolkit.models.config",
     "invoice": "rdetoolkit.models.invoice",
     "invoice_schema": "rdetoolkit.models.invoice_schema",
@@ -55,6 +70,9 @@ __all__ = [
     "rde2util",
     "rdelogger",
     "workflows",
+    "processing",
+    "storage",
+    "traceback",
     "config",
     "invoice",
     "invoice_schema",

rdetoolkit/cli/validate.py

@@ -13,7 +13,13 @@ if TYPE_CHECKING:
 
 app = typer.Typer(
     name="validate",
-    help="Validate RDE schema and data files",
+    help="""Validate RDE schema and data files.
+
+All validate commands use standardized exit codes:
+  0 = Success (validation passed)
+  1 = Validation failure (data/schema issues)
+  2 = Usage error (invalid arguments, missing files)
+""",
     no_args_is_help=True,
 )
 
@@ -87,10 +93,11 @@ def handle_validation_error(error: Exception, error_type: str) -> None:
         typer.echo(str(error), err=True)
         raise typer.Exit(code=1) from error
 
-    # Unknown errors get exit code 3 (internal error)
-    msg = f"Internal error during {error_type}: {error}"
+    # All other errors (including internal errors) map to exit code 2
+    # This includes unexpected exceptions that indicate configuration or usage issues
+    msg = f"Error during {error_type}: {error}"
     typer.echo(msg, err=True)
-    raise typer.Exit(code=3) from error
+    raise typer.Exit(code=2) from error
 
 
 # Common options for validation commands
@@ -141,6 +148,11 @@ def invoice_schema(
     Validates that the invoice schema file conforms to the expected structure
     and contains valid field definitions.
 
+    Exit Codes:
+        0: Success - validation passed
+        1: Validation failure - schema structure issues found
+        2: Usage error - file not found or invalid arguments
+
     Examples:
         rdetoolkit validate invoice-schema tasksupport/invoice.schema.json
         rdetoolkit validate invoice-schema schema.json --format json
@@ -151,6 +163,9 @@ def invoice_schema(
         command = InvoiceSchemaCommand(schema_path)
         result = command.execute()
         handle_validation_result(result, format_type, strict, quiet)
+    except typer.Exit:
+        # Re-raise typer.Exit to let Typer handle it properly
+        raise
     except FileNotFoundError:
         handle_file_not_found(schema_path, "Schema")
     except Exception as e:
@@ -177,6 +192,11 @@ def metadata_def(
     Validates that the metadata definition file conforms to the expected
     structure defined by the MetadataItem schema.
 
+    Exit Codes:
+        0: Success - validation passed
+        1: Validation failure - definition structure issues found
+        2: Usage error - file not found or invalid arguments
+
     Examples:
         rdetoolkit validate metadata-def tasksupport/metadata_def.json
         rdetoolkit validate metadata-def metadata_def.json --format json
@@ -187,6 +207,9 @@ def metadata_def(
         command = MetadataDefCommand(metadata_def_path)
         result = command.execute()
         handle_validation_result(result, format_type, strict, quiet)
+    except typer.Exit:
+        # Re-raise typer.Exit to let Typer handle it properly
+        raise
     except FileNotFoundError:
         handle_file_not_found(metadata_def_path, "Metadata definition")
     except Exception as e:
@@ -195,26 +218,22 @@ def metadata_def(
 
 @app.command("invoice")
 def invoice(
-    invoice_path: Annotated[
-        Path,
-        typer.Argument(
-            help="Path to invoice.json file",
-            exists=True,
-            dir_okay=False,
-            resolve_path=True,
-        ),
-    ],
-    schema_path: Annotated[
-        Path,
-        typer.Option(
-            "--schema",
-            "-s",
-            help="Path to invoice.schema.json file",
-            exists=True,
-            dir_okay=False,
-            resolve_path=True,
-        ),
-    ],
+    invoice_path: Path = typer.Argument(
+        ...,
+        help="Path to invoice.json file",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    schema_path: Path = typer.Option(
+        ...,
+        "--schema",
+        "-s",
+        help="Path to invoice.schema.json file",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
     format_type: FormatOption = OutputFormat.TEXT,
     strict: StrictOption = False,
     quiet: QuietOption = False,
@@ -224,6 +243,11 @@ def invoice(
     Validates that the invoice.json file conforms to the structure and
     constraints defined in the invoice.schema.json file.
 
+    Exit Codes:
+        0: Success - validation passed
+        1: Validation failure - data violates schema constraints
+        2: Usage error - files not found or invalid arguments
+
     Examples:
         rdetoolkit validate invoice raw/invoice.json --schema tasksupport/invoice.schema.json
         rdetoolkit validate invoice invoice.json -s schema.json --format json
@@ -251,26 +275,22 @@ def invoice(
 
 @app.command("metadata")
 def metadata(
-    metadata_path: Annotated[
-        Path,
-        typer.Argument(
-            help="Path to metadata.json file",
-            exists=True,
-            dir_okay=False,
-            resolve_path=True,
-        ),
-    ],
-    schema_path: Annotated[
-        Path,
-        typer.Option(
-            "--schema",
-            "-s",
-            help="Path to metadata definition JSON file",
-            exists=True,
-            dir_okay=False,
-            resolve_path=True,
-        ),
-    ],
+    metadata_path: Path = typer.Argument(
+        ...,
+        help="Path to metadata.json file",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
+    schema_path: Path = typer.Option(
+        ...,
+        "--schema",
+        "-s",
+        help="Path to metadata definition JSON file",
+        exists=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
     format_type: FormatOption = OutputFormat.TEXT,
     strict: StrictOption = False,
     quiet: QuietOption = False,
@@ -280,6 +300,11 @@ def metadata(
     Validates that the metadata.json file conforms to the structure
     defined in the metadata definition file.
 
+    Exit Codes:
+        0: Success - validation passed
+        1: Validation failure - data violates definition constraints
+        2: Usage error - files not found or invalid arguments
+
     Examples:
         rdetoolkit validate metadata raw/metadata.json --schema tasksupport/metadata_def.json
         rdetoolkit validate metadata metadata.json -s metadata_def.json --format json
@@ -290,6 +315,9 @@ def metadata(
         command = MetadataCommand(metadata_path, schema_path)
         result = command.execute()
         handle_validation_result(result, format_type, strict, quiet)
+    except typer.Exit:
+        # Re-raise typer.Exit to let Typer handle it properly
+        raise
     except FileNotFoundError:
         # Determine which file is missing
         if not metadata_path.exists():
@@ -304,16 +332,14 @@ def metadata(
 
 @app.command("all")
 def validate_all(
-    project_dir: Annotated[
-        Optional[Path],
-        typer.Argument(
-            help="Root directory of RDE project (defaults to current directory)",
-            exists=True,
-            file_okay=False,
-            dir_okay=True,
-            resolve_path=True,
-        ),
-    ] = None,
+    project_dir: Optional[Path] = typer.Argument(
+        None,
+        help="Root directory of RDE project (defaults to current directory)",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True,
+    ),
     format_type: FormatOption = OutputFormat.TEXT,
     strict: StrictOption = False,
     quiet: QuietOption = False,
@@ -329,7 +355,10 @@ def validate_all(
     - input/invoice/invoice.json (with schema)
     - input/metadata/metadata.json (if exists, with schema)
 
-    Exit code 0 only if ALL validations pass.
+    Exit Codes:
+        0: Success - all validations passed
+        1: Validation failure - one or more validations failed
+        2: Usage error - project directory not found or invalid arguments
 
     Examples:
         rdetoolkit validate all

rdetoolkit/cmd/validate.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional, Union
 
-from rdetoolkit.validation import InvoiceValidator, MetadataValidator
+from rdetoolkit.validation import InvoiceValidator, MetadataDefinitionValidator, MetadataValidator
 
 
 @dataclass
@@ -181,8 +181,7 @@ def determine_exit_code(result: ValidationResult, strict: bool = False) -> int:
     Exit codes:
     - 0: Validation passed
     - 1: Validation failed (errors or warnings in strict mode)
-    - 2: Usage/argument errors (handled by Typer)
-    - 3: Internal errors (handled by exception handlers)
+    - 2: Usage/argument errors (handled by CLI layer)
 
     Args:
         result: Validation result
@@ -428,7 +427,11 @@ class MetadataDefCommand(_ValidationErrorParser):
     """Command to validate metadata definition JSON files.
 
     This command validates metadata definition files using the
-    MetadataValidator's schema (MetadataItem pydantic model).
+    MetadataDefinitionValidator (for metadata-def.json structure).
+
+    Note:
+        This is separate from MetadataCommand which validates metadata.json
+        data files against metadata definition schemas.
     """
 
     def __init__(self, metadata_def_path: str | Path) -> None:
@@ -460,7 +463,8 @@ class MetadataDefCommand(_ValidationErrorParser):
         warnings: list[ValidationWarning] = []
 
         try:
-            validator = MetadataValidator()
+            # Use MetadataDefinitionValidator for metadata-def.json
+            validator = MetadataDefinitionValidator()
             # validate() with path parameter validates the file
             _ = validator.validate(path=self.metadata_def_path)
 
@@ -520,16 +524,15 @@ class MetadataCommand(_ValidationErrorParser):
         warnings: list[ValidationWarning] = []
 
         try:
-            # First validate the schema/definition itself
-            validator = MetadataValidator()
-            _ = validator.validate(path=self.schema_path)
-
-            # Then validate the metadata data against the schema
-            # Note: Current MetadataValidator validates individual items,
-            # not data against a separate schema. This is a structural difference
-            # from invoice validation. We validate that the metadata file
-            # conforms to MetadataItem structure.
-            _ = validator.validate(path=self.metadata_path)
+            # First validate the schema/definition file (metadata-def.json)
+            # Uses MetadataDefinitionValidator for dict[str, MetadataDefEntry] structure
+            def_validator = MetadataDefinitionValidator()
+            _ = def_validator.validate(path=self.schema_path)
+
+            # Then validate the metadata data file (metadata.json)
+            # Uses MetadataValidator for MetadataItem structure (constant/variable)
+            data_validator = MetadataValidator()
+            _ = data_validator.validate(path=self.metadata_path)
 
         except Exception as e:
             # Parse validation errors from exception message

rdetoolkit/config.py

@@ -6,8 +6,11 @@ from typing import Any, Final
 
 import yaml
 from pydantic import ValidationError
+from tomlkit.exceptions import TOMLKitError
 from tomlkit.toml_file import TOMLFile
+from yaml import YAMLError
 
+from rdetoolkit.exceptions import ConfigError
 from rdetoolkit.models.config import Config, TracebackSettings, MultiDataTileSettings, SystemSettings, SmartTableSettings
 from rdetoolkit.models.rde2types import RdeFsPath
 
@@ -16,6 +19,69 @@ PYPROJECT_CONFIG_FILES: Final = ["pyproject.toml"]
 CONFIG_FILES = CONFIG_FILE + PYPROJECT_CONFIG_FILES
 
 
+def _format_validation_error(
+    validation_error: ValidationError,
+    file_path: str,
+) -> ConfigError:
+    """Format pydantic ValidationError into user-friendly ConfigError.
+
+    Args:
+        validation_error: The pydantic ValidationError
+        file_path: Path to the configuration file
+
+    Returns:
+        ConfigError with detailed field-level information
+    """
+    errors = validation_error.errors()
+
+    if not errors:
+        return ConfigError(
+            "Configuration validation failed",
+            file_path=file_path,
+            error_type="validation_error",
+        )
+
+    # Take the first error for the main message
+    first_error = errors[0]
+    field_path = ".".join(str(loc) for loc in first_error["loc"])
+    error_msg = first_error["msg"]
+    error_type_detail = first_error["type"]
+
+    # Build detailed message
+    message_parts = [f"Invalid configuration in '{file_path}'"]
+
+    if field_path:
+        message_parts.append(f"Field '{field_path}' validation failed: {error_msg}")
+    else:
+        message_parts.append(f"Validation failed: {error_msg}")
+
+    # Add information about expected values if available
+    if "input" in first_error:
+        input_value = first_error["input"]
+        message_parts.append(f"Provided value: {input_value!r}")
+
+    # For extended_mode, provide specific guidance
+    if "extended_mode" in field_path and "enum" in error_type_detail.lower():
+        message_parts.append(
+            "Valid values for 'extended_mode': ['rdeformat', 'MultiDataTile']",
+        )
+
+    # Add validation error context if multiple errors exist
+    if len(errors) > 1:
+        message_parts.append(
+            f"Note: {len(errors)} validation error(s) found. Showing the first one.",
+        )
+
+    full_message = "\n".join(message_parts)
+
+    return ConfigError(
+        full_message,
+        file_path=file_path,
+        error_type="validation_error",
+        field_name=field_path,
+    )
+
+
 def parse_config_file(*, path: str | None = None) -> Config:
     """Parse the configuration file and return a Config object.
 
@@ -26,7 +92,7 @@ def parse_config_file(*, path: str | None = None) -> Config:
         Config: The parsed configuration object.
 
     Raises:
-        FileNotFoundError: If the specified configuration file does not exist.
+        ConfigError: If the specified configuration file does not exist or cannot be parsed.
 
     File Loading Priority:
         1. If `path` is provided and the file extension is ".toml", the function will attempt to read the file as a TOML file.
@@ -39,10 +105,14 @@ def parse_config_file(*, path: str | None = None) -> Config:
         - "pyproject.toml"
 
     Note:
-        - If the specified configuration file does not exist or is not in the correct format, an empty Config object will be returned.
+        - If the specified file is not a recognized config file name (not in CONFIG_FILES),
+          an empty Config object will be returned.
+        - If the specified file does not exist, ConfigError is raised.
+        - If the file contains invalid YAML/TOML syntax, ConfigError is raised with line/column info.
+        - If the configuration fails validation, ConfigError is raised with field details.
 
     Example:
-        parse_config_file(path="config.yaml")
+        parse_config_file(path="rdeconfig.yaml")
 
     """
     config_data: dict[str, Any] = {
@@ -50,14 +120,57 @@ def parse_config_file(*, path: str | None = None) -> Config:
         "multidata_tile": MultiDataTileSettings().model_dump(),
         "smarttable": SmartTableSettings().model_dump(),
     }
+
+    # Check file existence when path is provided
+    if path is not None:
+        path_obj = Path(path)
+        if not path_obj.exists():
+            msg = (
+                f"Configuration file not found: '{path}'. "
+                f"Create a configuration file or use 'rdetoolkit gen-config' to generate one."
+            )
+            raise ConfigError(
+                msg,
+                file_path=path,
+                error_type="file_not_found",
+            )
+
     if path is not None and Path(path).name not in CONFIG_FILES:
         return Config(system=SystemSettings(), multidata_tile=MultiDataTileSettings(), smarttable=SmartTableSettings())
 
     if path is not None and is_toml(path):
         config_data = __read_pyproject_toml(path)
     elif path is not None and is_yaml(path):
-        with open(path, encoding="utf-8") as f:
-            config_data = yaml.safe_load(f)
+        try:
+            with open(path, encoding="utf-8") as f:
+                config_data = yaml.safe_load(f)
+        except YAMLError as e:
+            # Extract line and column information from YAMLError
+            line_number = None
+            column_number = None
+
+            if hasattr(e, "problem_mark") and e.problem_mark is not None:
+                line_number = e.problem_mark.line + 1  # YAML uses 0-indexed lines
+                column_number = e.problem_mark.column + 1
+
+            error_msg = "Failed to parse YAML file: invalid syntax"
+            if hasattr(e, "problem"):
+                error_msg = f"Failed to parse YAML file: {e.problem}"
+
+            raise ConfigError(
+                error_msg,
+                file_path=path,
+                error_type="parse_error",
+                line_number=line_number,
+                column_number=column_number,
+            ) from e
+        except OSError as e:
+            msg = f"Failed to read YAML file: {e}"
+            raise ConfigError(
+                msg,
+                file_path=path,
+                error_type="io_error",
+            ) from e
     elif path is None:
         project_path = Path.cwd()
         pyproject_toml = project_path.joinpath(PYPROJECT_CONFIG_FILES[0])
@@ -68,19 +181,81 @@ def parse_config_file(*, path: str | None = None) -> Config:
     if config_data is None:
         return Config(system=SystemSettings(), multidata_tile=MultiDataTileSettings(), smarttable=SmartTableSettings())
 
-    return Config(**config_data)
+    try:
+        return Config(**config_data)
+    except ValidationError as e:
+        # Use helper to format validation error
+        if path:
+            raise _format_validation_error(e, path) from e
+        # Fallback for when path is None
+        msg = f"Configuration validation failed: {str(e)}"
+        raise ConfigError(
+            msg,
+            error_type="validation_error",
+        ) from e
+    except TypeError as e:
+        # This occurs when config_data is not a mapping (e.g., list or string),
+        # which makes Config(**config_data) invalid. Normalize it to ConfigError.
+        base_msg = "Configuration data must be a mapping (key-value structure)"
+        msg = f"{base_msg} in file '{path}'" if path else base_msg
+        raise ConfigError(
+            msg,
+            file_path=path,
+            error_type="validation_error",
+        ) from e
 
 
 def __read_pyproject_toml(path: str) -> dict[str, Any]:
     """Read the pyproject.toml file and return the contents as a dictionary.
 
+    Args:
+        path: Path to the pyproject.toml file
+
     Returns:
         dict[str, Any]: The contents of the pyproject.toml file.
+
+    Raises:
+        ConfigError: If the file does not exist or cannot be parsed
     """
-    toml = TOMLFile(path)
-    obj = toml.read()
-    _obj = obj.unwrap()
-    return _obj.get("tool", {}).get("rdetoolkit", {})
+    # Check file existence first
+    path_obj = Path(path)
+    if not path_obj.exists():
+        msg = (
+            f"Configuration file not found: '{path}'. "
+            f"Create a pyproject.toml file with [tool.rdetoolkit] section."
+        )
+        raise ConfigError(
+            msg,
+            file_path=path,
+            error_type="file_not_found",
+        )
+
+    try:
+        toml = TOMLFile(path)
+        obj = toml.read()
+        _obj = obj.unwrap()
+        return _obj.get("tool", {}).get("rdetoolkit", {})
+    except TOMLKitError as e:
+        # Extract line information if available
+        line_number = None
+        if hasattr(e, "line"):
+            line_number = e.line
+
+        error_msg = f"Failed to parse TOML file: {str(e)}"
+
+        raise ConfigError(
+            error_msg,
+            file_path=path,
+            error_type="parse_error",
+            line_number=line_number,
+        ) from e
+    except OSError as e:
+        msg = f"Failed to read TOML file: {e}"
+        raise ConfigError(
+            msg,
+            file_path=path,
+            error_type="io_error",
+        ) from e
 
 
 def is_toml(filename: str) -> bool:
@@ -153,27 +328,32 @@ def get_config(target_dir_path: RdeFsPath) -> Config | None:
 
     Returns:
         Optional[Config]: The first valid configuration found, or None if no valid configuration is found.
+
+    Raises:
+        ConfigError: If the target directory does not exist.
     """
     if isinstance(target_dir_path, str):
         target_dir_path = Path(target_dir_path)
     if not target_dir_path.exists():
-        return None
+        msg = (
+            f"Configuration directory not found: '{target_dir_path}'. "
+            f"Ensure the directory exists and contains a valid configuration file."
+        )
+        raise ConfigError(
+            msg,
+            file_path=str(target_dir_path),
+            error_type="directory_not_found",
+        )
     for cfg_file in find_config_files(target_dir_path):
-        try:
-            __config = parse_config_file(path=cfg_file)
-        except ValidationError as e:
-            emsg = f"Invalid configuration file: {cfg_file}"
-            raise ValueError(emsg) from e
+        # parse_config_file now converts ValidationError to ConfigError internally
+        __config = parse_config_file(path=cfg_file)
         if __config is not None:
             return __config
 
     pyproject_toml_path = get_pyproject_toml()
     if pyproject_toml_path is not None:
-        try:
-            __config = parse_config_file(path=str(pyproject_toml_path))
-        except ValidationError as e:
-            emsg = f"Invalid configuration file: {pyproject_toml_path}"
-            raise ValueError(emsg) from e
+        # parse_config_file now converts ValidationError to ConfigError internally
+        __config = parse_config_file(path=str(pyproject_toml_path))
         if __config is not None:
             return __config
     return None
@@ -194,8 +374,16 @@ def load_config(tasksupport_path: RdeFsPath, *, config: Config | None = None) ->
     if config is not None:
         __config = config
     else:
-        __rtn_config = get_config(tasksupport_path)
-        __config = Config() if __rtn_config is None else __rtn_config
+        try:
+            __rtn_config = get_config(tasksupport_path)
+            __config = Config() if __rtn_config is None else __rtn_config
+        except ConfigError as e:
+            # Only swallow directory_not_found errors for backward compatibility
+            # Re-raise other ConfigError types (parse_error, validation_error, etc.)
+            if getattr(e, "error_type", None) == "directory_not_found":
+                __config = Config()
+            else:
+                raise
     return __config
 
 

rdetoolkit/exceptions.py

@@ -176,3 +176,97 @@ class InvalidSearchParametersError(Exception):
     def __init__(self, message: str = "Invalid search term") -> None:
         self.message = message
         super().__init__(self.message)
+
+
+class ConfigError(Exception):
+    """Exception raised for configuration file loading errors.
+
+    This exception provides structured, informative error messages for configuration
+    file failures, including file paths, error types, line/column information for
+    parse errors, and documentation links.
+
+    Attributes:
+        message: The error message describing what went wrong.
+        file_path: Path to the configuration file that failed to load.
+        error_type: Type of error (e.g., 'file_not_found', 'parse_error', 'validation_error').
+        line_number: Line number where error occurred (for parse errors).
+        column_number: Column number where error occurred (for parse errors).
+        field_name: Field name that failed validation (for validation errors).
+        doc_url: Documentation URL for help and troubleshooting.
+
+    Examples:
+        File not found error:
+        >>> raise ConfigError(
+        ...     "Configuration file not found",
+        ...     file_path="config.yaml",
+        ...     error_type="file_not_found"
+        ... )
+
+        Parse error with line information:
+        >>> raise ConfigError(
+        ...     "Invalid YAML syntax: expected <block end>",
+        ...     file_path="config.yaml",
+        ...     error_type="parse_error",
+        ...     line_number=10,
+        ...     column_number=5
+        ... )
+
+        Validation error with field information:
+        >>> raise ConfigError(
+        ...     "Invalid value for field",
+        ...     file_path="config.yaml",
+        ...     error_type="validation_error",
+        ...     field_name="system.extended_mode"
+        ... )
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        file_path: str | None = None,
+        error_type: str = "unknown",
+        line_number: int | None = None,
+        column_number: int | None = None,
+        field_name: str | None = None,
+        doc_url: str = "https://nims-mdpf.github.io/rdetoolkit/usage/config/config/",
+    ) -> None:
+        """Initialize ConfigError with detailed information.
+
+        Args:
+            message: The error message describing what went wrong.
+            file_path: Path to the configuration file that failed.
+            error_type: Type of error (e.g., 'file_not_found', 'parse_error', 'validation_error').
+            line_number: Line number where error occurred (for parse errors).
+            column_number: Column number where error occurred (for parse errors).
+            field_name: Field name that failed validation (for validation errors).
+            doc_url: Documentation URL for help and troubleshooting.
+        """
+        self.message = message
+        self.file_path = file_path
+        self.error_type = error_type
+        self.line_number = line_number
+        self.column_number = column_number
+        self.field_name = field_name
+        self.doc_url = doc_url
+
+        # Build comprehensive error message
+        parts = []
+        if file_path:
+            parts.append(f"Configuration file: '{file_path}'")
+
+        parts.append(message)
+
+        if line_number is not None:
+            location = f"line {line_number}"
+            if column_number is not None:
+                location += f", column {column_number}"
+            parts.append(f"Location: {location}")
+
+        if field_name:
+            parts.append(f"Field: {field_name}")
+
+        parts.append(f"See: {doc_url}")
+
+        full_message = "\n".join(parts)
+        super().__init__(full_message)

rdetoolkit/exceptions.pyi

@@ -57,3 +57,24 @@ class NoResultsFoundError(Exception):
 class InvalidSearchParametersError(Exception):
     message: Incomplete
     def __init__(self, message: str = 'Invalid search term') -> None: ...
+
+class ConfigError(Exception):
+    message: str
+    file_path: str | None
+    error_type: str
+    line_number: int | None
+    column_number: int | None
+    field_name: str | None
+    doc_url: str
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        file_path: str | None = None,
+        error_type: str = 'unknown',
+        line_number: int | None = None,
+        column_number: int | None = None,
+        field_name: str | None = None,
+        doc_url: str = 'https://nims-mdpf.github.io/rdetoolkit/usage/config/config/',
+    ) -> None: ...

rdetoolkit/models/metadata.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Final
 
-from pydantic import BaseModel, RootModel, field_validator
+from pydantic import AnyUrl, BaseModel, ConfigDict, Field, RootModel, field_validator
 
 MAX_VALUE_SIZE: Final[int] = 1024
 
@@ -71,7 +71,7 @@ class ValidableItems(RootModel):
 
 
 class MetadataItem(BaseModel):
-    """metadata-def.json class.
+    """metadata.json class.
 
     Stores metadata extracted by the data structuring process.
 
@@ -82,3 +82,98 @@ class MetadataItem(BaseModel):
 
     constant: dict[str, MetaValue]
     variable: ValidableItems
+
+
+class NameField(BaseModel):
+    """Multilingual name field for metadata definition.
+
+    Attributes:
+        ja: Japanese name
+        en: English name
+    """
+
+    ja: str
+    en: str
+
+
+class SchemaField(BaseModel):
+    """Schema field for metadata definition.
+
+    Attributes:
+        type: Type of the metadata value. One of "array", "boolean", "integer", "number", "string"
+        format: Optional format specifier. One of "date-time" or "duration"
+    """
+
+    type: str  # "array", "boolean", "integer", "number", "string"
+    format: str | None = None  # "date-time", "duration"
+
+
+class MetadataDefEntry(BaseModel):
+    """Single metadata definition entry in metadata-def.json.
+
+    Represents one metadata item definition. This is used for metadata-def.json,
+    not for metadata.json (which uses MetadataItem instead).
+
+    Attributes:
+        name: Multilingual name (ja/en required)
+        schema_field: Type and format definition (type required, serialized as "schema")
+        unit: Optional unit for the metadata value
+        description: Optional description
+        uri: Optional URI/URL for the metadata key
+        mode: Optional measurement mode
+        order: Optional display order
+        original_name: Optional original name (serialized as "originalName")
+
+    Example:
+        ```json
+        {
+            "temperature": {
+                "name": {"ja": "温度", "en": "Temperature"},
+                "schema": {"type": "number"},
+                "unit": "K"
+            }
+        }
+        ```
+    """
+
+    name: NameField
+    schema_field: SchemaField = Field(alias="schema")
+    unit: str | None = None
+    description: str | None = None
+    uri: AnyUrl | None = None
+    mode: str | None = None
+    order: int | None = None
+    original_name: str | None = Field(default=None, alias="originalName")
+
+    model_config = ConfigDict(
+        # Allow undefined fields (e.g., "variable" field is ignored per docs)
+        extra="allow",
+        # Enable alias for JSON parsing and serialization
+        populate_by_name=True,
+    )
+
+
+class MetadataDefinition(RootModel):
+    """metadata-def.json root model.
+
+    Represents the entire metadata definition file as a dictionary
+    mapping metadata keys to their definitions. This is used for
+    metadata-def.json, not for metadata.json (which uses MetadataItem instead).
+
+    Example:
+        ```json
+        {
+            "temperature": {
+                "name": {"ja": "温度", "en": "Temperature"},
+                "schema": {"type": "number"},
+                "unit": "K"
+            },
+            "operator": {
+                "name": {"ja": "測定者", "en": "Operator"},
+                "schema": {"type": "string"}
+            }
+        }
+        ```
+    """
+
+    root: dict[str, MetadataDefEntry]

rdetoolkit/models/metadata.pyi

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, RootModel
+from pydantic import AnyUrl, BaseModel, RootModel
 from typing import Any, Final
 
 MAX_VALUE_SIZE: Final[int]
@@ -20,3 +20,24 @@ class ValidableItems(RootModel):
 class MetadataItem(BaseModel):
     constant: dict[str, MetaValue]
     variable: ValidableItems
+
+class NameField(BaseModel):
+    ja: str
+    en: str
+
+class SchemaField(BaseModel):
+    type: str
+    format: str | None
+
+class MetadataDefEntry(BaseModel):
+    name: NameField
+    schema_field: SchemaField
+    unit: str | None
+    description: str | None
+    uri: AnyUrl | None
+    mode: str | None
+    order: int | None
+    original_name: str | None
+
+class MetadataDefinition(RootModel):
+    root: dict[str, MetadataDefEntry]

rdetoolkit/validation.py

@@ -29,7 +29,19 @@ def _pydantic_validation_error() -> type[PydanticValidationError]:
 
 
 class MetadataValidator:
+    """Validator for metadata files (metadata.json).
+
+    This validator checks metadata.json files against the
+    MetadataItem Pydantic model, ensuring proper structure
+    for actual metadata data.
+
+    Note:
+        This is separate from MetadataDefinitionValidator which validates
+        metadata-def.json files (metadata definitions).
+    """
+
     def __init__(self) -> None:
+        """Initialize metadata validator with schema."""
         from rdetoolkit.models.metadata import MetadataItem
 
         self.schema = MetadataItem
@@ -59,28 +71,102 @@ class MetadataValidator:
 
         if path is not None:
             __data = readf_json(path)
-        elif json_obj is not None:
-            __data = json_obj
         else:
-            emsg = "Unexpected validation error"
-            raise ValueError(emsg)
+            __data = json_obj
 
         self.schema(**__data)
         return __data
 
 
+class MetadataDefinitionValidator:
+    """Validator for metadata definition files (metadata-def.json).
+
+    This validator checks metadata-def.json files against the
+    MetadataDefinition Pydantic model, ensuring proper structure
+    for metadata definitions.
+
+    Note:
+        This is separate from MetadataValidator which validates
+        metadata.json files (actual metadata data).
+    """
+
+    def __init__(self) -> None:
+        """Initialize metadata definition validator with schema."""
+        from rdetoolkit.models.metadata import MetadataDefinition
+
+        self.schema = MetadataDefinition
+
+    def validate(
+        self,
+        *,
+        path: str | Path | None = None,
+        json_obj: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Validate metadata definition JSON against schema.
+
+        Args:
+            path: Path to metadata-def.json file to validate
+            json_obj: JSON object to validate (alternative to path)
+
+        Returns:
+            Validated JSON data as dict
+
+        Raises:
+            ValueError: If neither path nor json_obj provided, or both provided
+            MetadataValidationError: If validation fails with detailed error info
+
+        Examples:
+            >>> validator = MetadataDefinitionValidator()
+            >>> data = validator.validate(path="metadata-def.json")
+        """
+        # Input validation
+        if path is None and json_obj is None:
+            emsg = "At least one of 'path' or 'json_obj' must be provided"
+            raise ValueError(emsg)
+        if path is not None and json_obj is not None:
+            emsg = "Both 'path' and 'json_obj' cannot be provided at the same time"
+            raise ValueError(emsg)
+
+        # Load data
+        if path is not None:
+            __data = readf_json(path)
+        else:
+            __data = json_obj
+
+        # Validate with Pydantic model
+        try:
+            self.schema(__data)
+        except _pydantic_validation_error() as validation_error:
+            # Format error message for metadata-def.json
+            emsg = "Validation Errors in metadata-def.json. Please correct the following fields\n"
+            for idx, error in enumerate(validation_error.errors(), start=1):
+                # Extract field path (e.g., ['key', 'name', 'ja'])
+                field_path = ".".join([str(e) for e in error["loc"]])
+                emsg += f"{idx}. Field: {field_path}\n"
+                emsg += f"   Type: {error['type']}\n"
+                emsg += f"   Context: {error['msg']}\n"
+            raise MetadataValidationError(emsg) from validation_error
+
+        return __data
+
+
 def metadata_validate(path: str | Path) -> None:
     """Validate metadata.json file.
 
-    This function validates the metadata definition file specified by the given path.
-    It checks if the file exists and then uses a validator to validate the file against a schema.
+    This function validates the metadata.json file (actual metadata data)
+    specified by the given path. It checks if the file exists and then uses
+    MetadataValidator to validate the file against the MetadataItem schema.
+
+    Note:
+        This function is for metadata.json files. For metadata-def.json
+        files, use MetadataDefinitionValidator instead.
 
     Args:
-        path (Union[str, Path]): The path to the metadata definition file.
+        path (Union[str, Path]): The path to the metadata.json file.
 
     Raises:
         FileNotFoundError: If the schema and path do not exist.
-        MetadataValidationError: If there is an error in validating the metadata definition file.
+        MetadataValidationError: If there is an error in validating the metadata file.
     """
     if isinstance(path, str):
         path = Path(path)

rdetoolkit/validation.pyi

@@ -8,6 +8,11 @@ class MetadataValidator:
     def __init__(self) -> None: ...
     def validate(self, *, path: str | Path | None = None, json_obj: dict[str, Any] | None = None) -> dict[str, Any]: ...
 
+class MetadataDefinitionValidator:
+    schema: Incomplete
+    def __init__(self) -> None: ...
+    def validate(self, *, path: str | Path | None = None, json_obj: dict[str, Any] | None = None) -> dict[str, Any]: ...
+
 def metadata_validate(path: str | Path) -> None: ...
 
 class InvoiceValidator:

rdetoolkit/workflows.py

@@ -419,8 +419,14 @@ def run(*, custom_dataset_function: DatasetCallback | None = None, config: Confi
         Exception: If a generic error occurs during the process.
 
     Note:
-        If `extended_mode` is specified, the evaluation of the execution mode is performed in the order of `extended_mode -> excelinvoice -> invoice`,
-        and the structuring process is executed.
+        Execution mode is selected in the following order:
+
+        1. SmartTable CSV is present (`smarttable_file` is not None) -> `SmartTableInvoice` mode.
+        2. Excel invoice bundle is provided (`excel_invoice_files` is not None) -> `Excelinvoice` mode.
+        3. `extended_mode` matches (case-insensitive) `rdeformat` or `MultiDataTile` -> the corresponding extended mode.
+        4. Otherwise -> `Invoice` mode.
+
+        The mode name recorded in logs/results matches the branch that executed. No `excelinvoice` value is accepted in `extended_mode`.
 
     Example:
         ```python

{rdetoolkit-1.5.1.dist-info → rdetoolkit-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdetoolkit
-Version: 1.5.1
+Version: 1.5.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -36,6 +36,7 @@ Requires-Dist: pyarrow>=19.0.0
 Requires-Dist: pip>=24.3.1
 Requires-Dist: rpds-py>=0.26
 Requires-Dist: markdown>=3.7
+Requires-Dist: pytz>=2024.1
 Requires-Dist: types-pytz>=2025.2.0.20250326
 Requires-Dist: matplotlib>=3.9.4
 Requires-Dist: minio>=7.2.15 ; extra == 'minio'
@@ -51,11 +52,11 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Bug Tracker, https://github.com/nims-dpfc/rdetoolkit
 Project-URL: Homepage, https://github.com/nims-dpfc/rdetoolkit
 
-![GitHub Release](https://img.shields.io/github/v/release/nims-dpfc/rdetoolkit)
+![GitHub Release](https://img.shields.io/github/v/release/nims-mdpf/rdetoolkit)
 [![python.org](https://img.shields.io/badge/Python-3.9%7C3.10%7C3.11%7C3.12%7C3.13%7C3.14-%233776AB?logo=python)](https://www.python.org/downloads/release/python-3917/)
-[![MIT License](https://img.shields.io/badge/license-MIT-green)](https://github.com/nims-dpfc/rdetoolkit/blob/main/LICENSE)
-[![Issue](https://img.shields.io/badge/issue_tracking-github-orange)](https://github.com/nims-dpfc/rdetoolkit/issues)
-![workflow](https://github.com/nims-dpfc/rdetoolkit/actions/workflows/main.yml/badge.svg)
+[![MIT License](https://img.shields.io/badge/license-MIT-green)](https://github.com/nims-mdpf/rdetoolkit/blob/main/LICENSE)
+[![Issue](https://img.shields.io/badge/issue_tracking-github-orange)](https://github.com/nims-mdpf/rdetoolkit/issues)
+![workflow](https://github.com/nims-mdpf/rdetoolkit/actions/workflows/main.yml/badge.svg)
 ![coverage](docs/img/coverage.svg)
 
 > [日本語ドキュメント](docs/README_ja.md)
@@ -76,6 +77,13 @@ If you wish to make changes, please read the following document first:
 
 - [CONTRIBUTING.md](https://github.com/nims-mdpf/rdetoolkit/blob/main/CONTRIBUTING.md)
 
+## Requirements
+
+- **Python**: 3.9 or higher (Python 3.9 support will be removed in v2.0; upgrade to Python 3.10+ recommended)
+
+!!! warning "Python 3.9 Deprecation"
+    Python 3.9 support is deprecated and will be removed in rdetoolkit v2.0. While Python 3.9 continues to work in rdetoolkit 1.x, users will see a `DeprecationWarning` on import. Please plan to upgrade to Python 3.10 or later before the v2.0 release.
+
 ## Install
 
 To install, run the following command:
@@ -143,20 +151,20 @@ def dataset(paths: RdeDatasetPaths) -> None:
     ...
 ```
 
-In this example, we define a dummy function `display_messsage()` under `modules` to demonstrate how to implement custom structuring processing. Create a file named `modules/modules.py` as follows:
+In this example, we define a dummy function `display_message()` under `modules` to demonstrate how to implement custom structuring processing. Create a file named `modules/modules.py` as follows:
 
 ```python
 # modules/modules.py
 from rdetoolkit.models.rde2types import RdeDatasetPaths
 
 
-def display_messsage(path):
+def display_message(path):
     print(f"Test Message!: {path}")
 
 
 def dataset(paths: RdeDatasetPaths) -> None:
-    display_messsage(paths.inputdata)
-    display_messsage(paths.struct)
+    display_message(paths.inputdata)
+    display_message(paths.struct)
 ```
 
 ### About the Entry Point

{rdetoolkit-1.5.1.dist-info → rdetoolkit-1.5.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-rdetoolkit\__init__.py,sha256=3ZdviQQC5mW8GwghHDpg79YrnWbBzlH2g8eoKlbVOk8,2801
+rdetoolkit\__init__.py,sha256=JHyHP569oIiGeWRopO7rd0KelZFxsHzIFri753zqaGo,3306
 rdetoolkit\__init__.pyi,sha256=2ILXdK0bu7extORHJnwcCw2GHmlSGrN6-hDV0SV7CF8,472
 rdetoolkit\__main__.py,sha256=RpkjdhIR-v6U17ZAnT3DAIcDwADDqQabSkQoNFiCXQk,126
 rdetoolkit\__main__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -9,7 +9,7 @@ rdetoolkit\artifact\report.pyi,sha256=yTvSNg6JDqobsS5uhU1-RX_5qwabmOwBXqPNKOzgiR
 rdetoolkit\cli\__init__.py,sha256=ZJ5C5YbpaRC3rnavu1_zG30WJ6sePrTcuvmVwAla9sc,1832
 rdetoolkit\cli\app.py,sha256=GPhLbnYs3ufGVu4qUgHtx4ZP5jHk4uR7jocQHffuIgY,19281
 rdetoolkit\cli\app.pyi,sha256=EyyA59hDGfQ7oo0MysCtmoIIotyj7yZUsCT-VRR7cPo,2131
-rdetoolkit\cli\validate.py,sha256=aw226KaYdv5Teyqx2r5qpdCuWO3LfAJ1sF_XYQKT_t0,13428
+rdetoolkit\cli\validate.py,sha256=BhFn_N8fveCnJ9LWSW4TJnWhPtlemvLjlB_-8IoMG_4,14695
 rdetoolkit\cli\validate.pyi,sha256=3o8rsuY_l018FBUs0mXUOXDyMmE1TE244f54Eiaa2Wg,1734
 rdetoolkit\cli.pyi,sha256=eJk2lAG9DVnEi9woNVwVfqpFtzCV40EaOyjuSo77m84,1648
 rdetoolkit\cmd\__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -26,16 +26,16 @@ rdetoolkit\cmd\gen_config.py,sha256=4l8R1uMW7HbZi23K4yGolXSEOgKrT0efEoIdBn_qXN0,
 rdetoolkit\cmd\gen_config.pyi,sha256=zBY4XATVx_dDf_Vlkc9wqpgOSWNcTudKXueu_hTHW8I,1120
 rdetoolkit\cmd\gen_excelinvoice.py,sha256=4EiV3PUkYUzn29fDutYsZ14POOtaA0RL0GLN8swM69Q,2136
 rdetoolkit\cmd\gen_excelinvoice.pyi,sha256=GrywtydtlXyYeHBY2fHCh3BQOfGG90807rIMOFo5sig,407
-rdetoolkit\cmd\validate.py,sha256=i8nx6-Q4S5rxq0K07eByrfI_a9_fijewSZPSkk51qm8,27909
+rdetoolkit\cmd\validate.py,sha256=wFWbOEKvzpq3zur7wYMjvLfwxDg3zxM42PJefG4RgXY,28099
 rdetoolkit\cmd\validate.pyi,sha256=75ca4HTq93Z1ZFtlo7hGFiMVUoswvzCOjdWaaHvnBME,2691
-rdetoolkit\config.py,sha256=3u_bUtElA55ix6-mS6IlPw9S3hWHFowHehxFHITcZIA,8690
+rdetoolkit\config.py,sha256=7sblHYkOzMPg7cdkBNO4ynnxko896fW6AH6QY8GULfs,15301
 rdetoolkit\config.pyi,sha256=MUZCZXOJtcIGWGNNtKToAfWnf7llO9Bdy4HxULNIYXQ,969
-rdetoolkit\core.cp314-win_amd64.pyd,sha256=TZ6MGBk9CkNETIfVPAZ_nCO62xqpNFsQjgO0JaAOpTc,6771712
+rdetoolkit\core.cp314-win_amd64.pyd,sha256=vpcpWeBq7cDOz0KpS3cmB59P7V0RYjlOL3qT4pdU8vI,6771712
 rdetoolkit\core.pyi,sha256=VxUXk6kEkwsA5a8t0FtfTPt5VtfHjMy7yMz9UzG6r4U,3154
 rdetoolkit\errors.py,sha256=j2tHMViF3WsLXcsyTtC2uq0bOMagdB3Dg5J58-jnF5k,13966
 rdetoolkit\errors.pyi,sha256=XRnfjCkS3k6NIncUUnvDEK9_9Yfe5dghnN1jXZr_9mE,1445
-rdetoolkit\exceptions.py,sha256=BUGi457cXceAHfD8a81tJrB7qnS-YkoCoaSpqemxn3E,7527
-rdetoolkit\exceptions.pyi,sha256=0XlSHaoa_sfg7t9HlRVuBO4fa6k8UcH_v-M_-8_hdIk,2180
+rdetoolkit\exceptions.py,sha256=W8JICpzsNfmN2T68poI5bbGGykuyUmG6yC5JEM3uSl4,11126
+rdetoolkit\exceptions.pyi,sha256=zJrKfbT-4yCXWOUPN36yqzppV5sH3ijDQwNdk00IU4c,2764
 rdetoolkit\fileops.py,sha256=UgiEWIMD5JCwPYbX6bloj1J9PJSA3iyRERNG49yNIPc,2041
 rdetoolkit\fileops.pyi,sha256=_UP6GbYdPODUby6TSV7maKnU2xD4_ttUg-bKmjbnNEY,325
 rdetoolkit\graph\__init__.py,sha256=4txp3FJ-rroWXIDv8mqF8ZxtiBUh8qs2vsy6Y96epLU,3106
@@ -121,8 +121,8 @@ rdetoolkit\models\invoice.py,sha256=3J1f7_is7fdFkmFwXmgSJ79ydh0dL8AvV2-DZ_suHRE,
 rdetoolkit\models\invoice.pyi,sha256=t5SOOq1ZwjfJ0LyfuL2N8ChnuWW7CMuvN2-E-imEhDk,2983
 rdetoolkit\models\invoice_schema.py,sha256=57S8yjLpH2fzvLYn7oSZ85b92-C8Txlf1ifRyLr-Vsc,16936
 rdetoolkit\models\invoice_schema.pyi,sha256=QlDeARuGa4KzOr44iFkjUQgp-RJkaSfBqcucS7Us0vc,3731
-rdetoolkit\models\metadata.py,sha256=ZdQkRdNpp1ctYcjmD5abatg6hULVjBb0rKn0kgdfuFs,2655
-rdetoolkit\models\metadata.pyi,sha256=F1KzmnWmWLAPFIwoGV4orIYRIeRVt0XdFUkn5G2OmoY,567
+rdetoolkit\models\metadata.py,sha256=4IYN1FKenqejR_wpt3dTIfuv6YxL0QCrU68YeqTmZ5M,5562
+rdetoolkit\models\metadata.pyi,sha256=ObHQUf8I4dCdCYC33paBYHfn7V7cw62sVeZ-k4lMu2Y,1024
 rdetoolkit\models\rde2types.py,sha256=i2U-qpl2ynj-sSKdTY1FRxkP_hj--aIXTVr2pdlcY-I,32345
 rdetoolkit\models\rde2types.pyi,sha256=KiUjEDdZM2Nkmq5mZI2LU9fgpY8DzVym3MiqafOswcg,7644
 rdetoolkit\models\reports.py,sha256=KWjskAMJAEgwuciOOGVmnYIasEjZtX2q9vXc9JkjvWA,422
@@ -180,12 +180,12 @@ rdetoolkit\traceback\formatter.py,sha256=WnJmQkRvQsIY-nKrh13GjkTvL2PY_1iVw5gKn_M
 rdetoolkit\traceback\formatter.pyi,sha256=Ry2FHNLfOZXDHSxsTR0tPktyZ0GYKXKsOFiO-opqScE,398
 rdetoolkit\traceback\masking.py,sha256=9CjqmbPmRBhszgktIgp9x60KKumELIuf9ILFUeCO438,4678
 rdetoolkit\traceback\masking.pyi,sha256=cbejAwTmUr7nasHfJzb8wJYciBaBCws5KPYe_TW0PQU,652
-rdetoolkit\validation.py,sha256=Rh4XZcusrNlUZApY20X5sM2IXn-f9b7eyNUto67LAAA,15247
-rdetoolkit\validation.pyi,sha256=mkv2LnC4FEZwT7INCEzdGBlOzyKEfc0J80TAWtTQbp0,778
-rdetoolkit\workflows.py,sha256=U9Xz8xnrZcp257VtCimtdSuc9h_Q0MVhilDo7gDO8l0,22062
+rdetoolkit\validation.py,sha256=ZIdULGWAzQHv8VdfbBZuKSD5eZHtjsMsBhPDD3y4uCA,18416
+rdetoolkit\validation.pyi,sha256=916wLyRHzqtr9UNL9p8_vQC9ya-OpLDMOZkKukfKuyw,999
+rdetoolkit\workflows.py,sha256=jVz_CHbNAVc2FLVyfV-Dhan-EWvoZDKWhMqXZVdwI38,22429
 rdetoolkit\workflows.pyi,sha256=i2QN0RP0xQYCjs1Ctp1y6zoRBqeB0cCw7mYlDAS2jiQ,2199
-rdetoolkit-1.5.1.dist-info\METADATA,sha256=ChV-YRcHDR2G6knOuosSYUkBudL8v0sriXuJCyTsUHM,8671
-rdetoolkit-1.5.1.dist-info\WHEEL,sha256=TASrtxyeL-Pi7odwPBMCgR1YebCHdBFZvgqiADG_4b0,97
-rdetoolkit-1.5.1.dist-info\entry_points.txt,sha256=WMEB0vLFWxdgPfIxgGPzK2djc-aVoGclcqvZlXxpxu4,52
-rdetoolkit-1.5.1.dist-info\licenses\LICENSE,sha256=Xh2kqHbF9jlxeCxl_60qCRAAuO8DYe2hkv0bBAjxcko,1103
-rdetoolkit-1.5.1.dist-info\RECORD,,
+rdetoolkit-1.5.2.dist-info\METADATA,sha256=LyLSFsBegG4HM6cBzcfqacmfOnkKT30TBcLjiC7sQPU,9120
+rdetoolkit-1.5.2.dist-info\WHEEL,sha256=TASrtxyeL-Pi7odwPBMCgR1YebCHdBFZvgqiADG_4b0,97
+rdetoolkit-1.5.2.dist-info\entry_points.txt,sha256=WMEB0vLFWxdgPfIxgGPzK2djc-aVoGclcqvZlXxpxu4,52
+rdetoolkit-1.5.2.dist-info\licenses\LICENSE,sha256=Xh2kqHbF9jlxeCxl_60qCRAAuO8DYe2hkv0bBAjxcko,1103
+rdetoolkit-1.5.2.dist-info\RECORD,,