dataorc-utils 0.1.0__tar.gz

dataorc_utils-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: dataorc-utils
+Version: 0.1.0
+Summary: Utility functions for ETL operations
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.8.0; extra == "dev"

dataorc_utils-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dataorc-utils"
+version = "0.1.0"
+description = "Utility functions for ETL operations"
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=7.0",
+    "ruff>=0.8.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+# Set the maximum line length to 88.
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "B", "I"]
+
+[tool.isort]
+profile = "black"
+line_length = 88

dataorc_utils-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dataorc_utils-0.1.0/src/dataorc_utils/__init__.py

@@ -0,0 +1,22 @@
+"""Dataorc Utils
+
+A collection of utility functions for ETL operations.
+"""
+
+__author__ = "Equinor"
+__email__ = "toarst@equinor.com"
+
+# Import main functions/classes here to make them available at package level
+# Example:
+# from .core import some_function
+# from .utils import another_function
+
+# Re-export subpackages / common symbols for convenience.
+# This allows: `from dataorc_utils import config` or
+# `from dataorc_utils.config import CorePipelineConfig`.
+from . import config  # convenient access to the config subpackage
+
+# __all__ defines what gets imported with "from dataorc_utils import *"
+__all__ = [
+    "config",
+]

dataorc_utils-0.1.0/src/dataorc_utils/config/__init__.py

@@ -0,0 +1,21 @@
+"""
+Config package public API.
+
+This module re-exports the most commonly used symbols from the
+submodules so callers can `from dataorc_utils.config import ...`.
+"""
+
+from .enums import CoreParam, Defaults, Environment
+from .manager import PipelineParameterManager
+from .models import CorePipelineConfig, InfraContext
+from .validation import print_config
+
+__all__ = [
+    "Environment",
+    "CoreParam",
+    "Defaults",
+    "InfraContext",
+    "CorePipelineConfig",
+    "print_config",
+    "PipelineParameterManager",
+]

dataorc_utils-0.1.0/src/dataorc_utils/config/enums.py

@@ -0,0 +1,51 @@
+"""
+Core parameter definitions and enums.
+"""
+
+from enum import Enum
+
+
+class Environment(str, Enum):
+    """Pipeline execution environments."""
+
+    DEV = "dev"
+    TEST = "test"
+    PROD = "prod"
+
+
+class CoreParam(str, Enum):
+    """Core parameters used across all pipelines."""
+
+    # Environment and data lake
+    DATALAKE_NAME = "datalake_name"
+    DATALAKE_CONTAINER_NAME = "datalake_container_name"
+    ENV = "env"
+
+    # Data Lake Structure Parameters
+    # Following pattern: containername/{layer}/{domain}/{product}/{version}/output/{processing_method}
+    DOMAIN = "domain"  # Business domain  -> Catalog name
+    PRODUCT = "product"  # Product/project  -> Database name
+    TABLE_NAME = "table_name"  # Table name within the product/database
+
+    # layers
+    BRONZE_VERSION = "bronze_version"  # Version for bronze layer
+    SILVER_VERSION = "silver_version"  # Version for silver layer
+    GOLD_VERSION = "gold_version"  # Version for gold layer
+
+    # Processing Methods (layer-specific, user-configurable)
+    BRONZE_PROCESSING_METHOD = "bronze_processing_method"  # incremental, full, delta
+    SILVER_PROCESSING_METHOD = "silver_processing_method"  # incremental, full, delta
+    GOLD_PROCESSING_METHOD = "gold_processing_method"  # incremental, full, delta
+
+
+# Default values - co-located with their semantic meaning
+class Defaults:
+    """Default values for pipeline configuration."""
+
+    # Version defaults
+    VERSION = "v1"
+
+    # Processing method defaults
+    BRONZE_PROCESSING_METHOD = "incremental"
+    SILVER_PROCESSING_METHOD = "incremental"
+    GOLD_PROCESSING_METHOD = "delta"

dataorc_utils-0.1.0/src/dataorc_utils/config/manager.py

@@ -0,0 +1,174 @@
+"""
+Parameter management for pipeline configuration.
+
+This manager reads configuration from environment variables.
+Cluster environment variables / wheel packaging.
+"""
+
+import os
+
+from .enums import CoreParam, Defaults, Environment
+from .models import CorePipelineConfig, InfraContext
+
+
+class PipelineParameterManager:
+    """
+    General parameter manager for data pipelines.
+
+    This manager is designed to work with repository-specific configurations.
+    Most repositories should create their own wrapper that provides the
+    repository-specific configuration dictionaries.
+    """
+
+    def __init__(
+        self,
+        environments_config: dict = None,
+        domain_configs: dict = None,
+        product_configs: dict = None,
+        case_fallback: bool = False,
+    ):
+        """
+        Initialize parameter manager.
+
+        Args:
+            environments_config: Dictionary of environment configurations
+            domain_configs: Dictionary of domain configurations
+            product_configs: Dictionary of product configurations
+        """
+        # Wheel-based packaging for configuration delivery.
+        self.environments_config = environments_config or {}
+        self.domain_configs = domain_configs or {}
+        self.product_configs = product_configs or {}
+        self.case_fallback = case_fallback
+        self._local_environment = Environment.DEV  # Default for local development
+
+    def _get_default_value(self, param: CoreParam) -> str:
+        """Get default value for a core parameter."""
+        defaults_map = {
+            CoreParam.BRONZE_VERSION: Defaults.VERSION,
+            CoreParam.SILVER_VERSION: Defaults.VERSION,
+            CoreParam.GOLD_VERSION: Defaults.VERSION,
+            CoreParam.BRONZE_PROCESSING_METHOD: Defaults.BRONZE_PROCESSING_METHOD,
+            CoreParam.SILVER_PROCESSING_METHOD: Defaults.SILVER_PROCESSING_METHOD,
+            CoreParam.GOLD_PROCESSING_METHOD: Defaults.GOLD_PROCESSING_METHOD,
+        }
+        return defaults_map.get(param, "")
+
+    def get_env_variables(
+        self, var_names: list[str], required: bool = False
+    ) -> dict[str, str]:
+        """
+        Retrieve environment variables by name.
+
+        Args:
+            var_names: List of environment variable names to retrieve
+            required: If True, raises ValueError when a variable is missing
+
+        Returns:
+            Dictionary mapping variable names to their values (empty string for missing vars)
+
+        Raises:
+            ValueError: If required=True and any variable is not set
+        """
+        result = {}
+        missing = []
+
+        for var_name in var_names:
+            # Lookup strategy: exact first. If case_fallback enabled, try UPPER then lower.
+            env_value = os.getenv(var_name)
+            if env_value is None and self.case_fallback:
+                if var_name.upper() != var_name:
+                    env_value = os.getenv(var_name.upper())
+                if env_value is None and var_name.lower() != var_name:
+                    env_value = os.getenv(var_name.lower())
+
+            if env_value is not None:
+                result[var_name] = env_value
+            else:
+                if required:
+                    missing.append(var_name)
+                else:
+                    result[var_name] = ""
+
+        if missing:
+            raise ValueError(
+                f"Required environment variables not set: {', '.join(missing)}"
+            )
+
+        return result
+
+    def prepare_infrastructure(self, env_vars: list[str]) -> InfraContext:
+        """Read and return infrastructure context (no dataset identifiers).
+
+        Args:
+            env_vars: List of infrastructure environment variable names to capture
+                (e.g., ["datalake_name", "datalake_container_name", "az_tenant_id"]).
+                These will be stored in InfraContext.variables.
+
+        Returns:
+            InfraContext with env and requested infrastructure variables
+
+        Raises:
+            ValueError: If the ENV environment variable is not set in environment
+        """
+        # Get the environment (always required)
+        env_value = os.getenv(CoreParam.ENV.value)
+        if not env_value:
+            raise ValueError(
+                f"Required environment variable '{CoreParam.ENV.value}' is not set"
+            )
+
+        env = Environment(env_value)
+
+        # Capture infrastructure variables
+        infra_vars = self.get_env_variables(env_vars, required=False)
+
+        return InfraContext(
+            env=env,
+            variables=infra_vars,
+        )
+
+    def build_core_config(
+        self,
+        infra: InfraContext,
+        domain: str = "",
+        product: str = "",
+        table_name: str = "",
+        bronze_version: str | None = None,
+        silver_version: str | None = None,
+        gold_version: str | None = None,
+        bronze_processing_method: str | None = None,
+        silver_processing_method: str | None = None,
+        gold_processing_method: str | None = None,
+    ) -> CorePipelineConfig:
+        """Compose a CorePipelineConfig from infra plus pipeline-specific overrides."""
+        # Resolve defaults if None supplied
+        bv = bronze_version or self._get_default_value(CoreParam.BRONZE_VERSION)
+        sv = silver_version or self._get_default_value(CoreParam.SILVER_VERSION)
+        gv = gold_version or self._get_default_value(CoreParam.GOLD_VERSION)
+
+        bpm = bronze_processing_method or self._get_default_value(
+            CoreParam.BRONZE_PROCESSING_METHOD
+        )
+        spm = silver_processing_method or self._get_default_value(
+            CoreParam.SILVER_PROCESSING_METHOD
+        )
+        gpm = gold_processing_method or self._get_default_value(
+            CoreParam.GOLD_PROCESSING_METHOD
+        )
+
+        config = CorePipelineConfig(
+            env=infra.env,
+            domain=domain,
+            product=product,
+            table_name=table_name,
+            bronze_version=bv,
+            silver_version=sv,
+            gold_version=gv,
+            bronze_processing_method=bpm,
+            silver_processing_method=spm,
+            gold_processing_method=gpm,
+            env_vars=infra.variables,
+        )
+        config.validate_rules()
+        return config

dataorc_utils-0.1.0/src/dataorc_utils/config/models.py

@@ -0,0 +1,155 @@
+"""Core configuration data classes."""
+
+from dataclasses import dataclass, field
+
+from .enums import Defaults, Environment
+
+
+@dataclass
+class InfraContext:
+    """Infrastructure-level context captured prior to pipeline specifics.
+
+    Stable across multiple pipeline jobs; excludes dataset identifiers and
+    per-layer version/processing configuration.
+
+    The `variables` dict holds all infrastructure environment variables
+    (e.g., datalake_name, datalake_container_name, Azure tenant/client IDs, etc.)
+    that were requested when calling prepare_infrastructure().
+    """
+
+    env: Environment
+    variables: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class CorePipelineConfig:
+    """Immutable pipeline configuration snapshot.
+
+    Path pattern: container/{layer}/{domain}/{product}/{table_name}/{version}/output/{processing_method}
+    Construct via PipelineParameterManager.build_core_config() in production code.
+
+    The `env_vars` dict holds infrastructure environment variables
+    (e.g., datalake_name, datalake_container_name, Azure IDs, etc.) captured during
+    prepare_infrastructure().
+    """
+
+    # Required
+    env: Environment
+
+    # Structure identifiers
+    domain: str = ""
+    product: str = ""
+    table_name: str = ""
+
+    # Layer versions
+    bronze_version: str = Defaults.VERSION
+    silver_version: str = Defaults.VERSION
+    gold_version: str = Defaults.VERSION
+
+    # Processing methods
+    bronze_processing_method: str = Defaults.BRONZE_PROCESSING_METHOD
+    silver_processing_method: str = Defaults.SILVER_PROCESSING_METHOD
+    gold_processing_method: str = Defaults.GOLD_PROCESSING_METHOD
+
+    # Flexible infrastructure variables (datalake_name, container, Azure IDs, etc.)
+    env_vars: dict[str, str] = field(default_factory=dict)
+    # Convenience properties that return the canonical lake path for each layer.
+
+    def get_lake_path(
+        self,
+        layer: str,
+        processing_method_override: str = None,
+        version_override: str = None,
+        domain_override: str = None,
+        product_override: str = None,
+        table_name_override: str = None,
+    ) -> str:
+        """
+            Generate Data Lake path following the standard structure.
+
+        Structure: containername/{layer}/{domain}/{product}/{table_name}/{version}/output/{processing_method}
+
+            Args:
+                layer: bronze, silver, or gold
+                processing_method_override: override processing method for specific layer
+                version_override: override version for specific layer
+
+            Returns:
+                Full data lake path
+        """
+        # Allow callers to override identifiers; fall back to the instance values.
+        domain = domain_override or self.domain
+        product = product_override or self.product
+        table_name = table_name_override or self.table_name
+        container = self.env_vars.get("datalake_container_name", "")
+
+        if not all([container, domain, product, table_name]):
+            raise ValueError(
+                "datalake_container_name, domain, product and table_name must be set to generate lake path"
+            )
+
+        # Resolve attribute names directly (e.g. bronze_version, bronze_processing_method)
+        v_attr = f"{layer}_version"
+        p_attr = f"{layer}_processing_method"
+
+        version = version_override or getattr(self, v_attr, Defaults.VERSION)
+        processing_method = processing_method_override or getattr(
+            self, p_attr, Defaults.BRONZE_PROCESSING_METHOD
+        )
+
+        return f"{container}/{layer}/{domain}/{product}/{table_name}/{version}/output/{processing_method}"
+
+    def get_work_path(
+        self,
+        layer: str,
+        version_override: str = None,
+        domain_override: str = None,
+        product_override: str = None,
+        table_name_override: str = None,
+    ) -> str:
+        """Return the working path for a layer.
+
+        This reuses `get_lake_path(...)` and replaces the trailing
+        `/output/{processing_method}` segment with `/work`. If the
+        expected `/output/` segment isn't found, `/work` is appended.
+        """
+        # Reuse get_lake_path to compose the canonical path and then
+        # convert it to a work path by replacing the output segment.
+        lake_path = self.get_lake_path(
+            layer,
+            processing_method_override=None,
+            version_override=version_override,
+            domain_override=domain_override,
+            product_override=product_override,
+            table_name_override=table_name_override,
+        )
+
+        marker = "/output/"
+        idx = lake_path.find(marker)
+        if idx >= 0:
+            return lake_path[:idx] + "/work"
+        # Fallback: append /work if format differs
+        return lake_path.rstrip("/") + "/work"
+
+    def validate_rules(self, layers: list | None = None) -> bool:
+        """Run repository-config rules against this CorePipelineConfig.
+
+        Delegates to `run_rules_checks` and returns True if checks pass or
+        raises ValueError if any rule fails.
+        """
+        # Import locally to avoid circular imports at module import time
+        from .rules import run_rules_checks
+
+        return run_rules_checks(self, layers)
+
+    @property
+    def bronze_lake_path(self) -> str:
+        return self.get_lake_path("bronze")
+
+    @property
+    def silver_lake_path(self) -> str:
+        return self.get_lake_path("silver")
+
+    @property
+    def gold_lake_path(self) -> str:
+        return self.get_lake_path("gold")

dataorc_utils-0.1.0/src/dataorc_utils/config/rules.py

@@ -0,0 +1,88 @@
+"""Rule framework for configuration validation.
+
+Extensible mechanism for validating `CorePipelineConfig` objects. Each rule is a
+callable taking (config, layer) and returning True or raising ValueError.
+
+Built‑in rules:
+- `lowercase_lake_path_rule`: lake paths must not contain uppercase letters.
+
+Add new rules by appending to `RULES` or passing a custom list to
+`run_rules_checks`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Callable, Iterable, List
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .models import CorePipelineConfig
+
+RuleFunc = Callable[["CorePipelineConfig", str], bool]
+
+
+def lowercase_lake_path_rule(config: "CorePipelineConfig", layer: str) -> bool:
+    path = config.get_lake_path(layer)
+    if any(ch.isalpha() and ch.isupper() for ch in path):
+        raise ValueError(f"Lake path contains uppercase letters: '{path}'")
+    return True
+
+
+_VERSION_PATTERN = re.compile(r"^v[0-9]+$")
+
+
+def version_format_rule(config: "CorePipelineConfig", layer: str) -> bool:
+    """Ensure the version segment for the layer matches pattern v<integer>.
+
+    It derives the layer-specific version attribute (e.g. bronze_version) and validates
+    it matches the required pattern. Also verifies that the lake path actually embeds
+    that exact version token (defensive consistency check).
+    """
+    attr = f"{layer}_version"
+    value = getattr(config, attr)
+    if not isinstance(value, str) or not _VERSION_PATTERN.match(value):
+        raise ValueError(
+            f"Version for layer '{layer}' must match pattern 'v<integer>' (e.g. v1); got: {value!r}"
+        )
+    path = config.get_lake_path(layer)
+    # Ensure token boundary match in path
+    if f"/{value}/" not in path:
+        raise ValueError(
+            f"Lake path for layer '{layer}' does not include expected version token '{value}': {path}"
+        )
+    return True
+
+
+RULES: List[RuleFunc] = [lowercase_lake_path_rule, version_format_rule]
+
+
+def run_rules_checks(
+    config: "CorePipelineConfig",
+    layers: Iterable[str] | None = None,
+    rules: Iterable[RuleFunc] | None = None,
+) -> bool:
+    if layers is None:
+        layers = ("bronze", "silver", "gold")
+    if rules is None:
+        rules = RULES
+
+    errors: list[str] = []
+    for layer in layers:
+        for rule in rules:
+            try:
+                rule(config, layer)
+            except Exception as exc:  # noqa: BLE001
+                errors.append(f"[{layer}] {exc}")
+
+    if errors:
+        raise ValueError("Rule checks failed:\n" + "\n".join(errors))
+    return True
+
+
+__all__ = [
+    "RuleFunc",
+    "RULES",
+    "lowercase_lake_path_rule",
+    "version_format_rule",
+    "run_rules_checks",
+]

dataorc_utils-0.1.0/src/dataorc_utils/config/validation.py

@@ -0,0 +1,49 @@
+"""
+Parameter validation logic.
+"""
+
+from .models import CorePipelineConfig
+
+
+def print_config(
+    config: CorePipelineConfig, title: str = "Pipeline Configuration"
+) -> None:
+    """Print configuration for debugging."""
+    print(f"📦 {title}:")
+    # Handle both string and enum types
+    env_value = config.env.value if hasattr(config.env, "value") else str(config.env)
+
+    print(f"   Environment: {env_value}")
+
+    print("   🏗️ Data Lake Structure:")
+    print(f"     Domain: {config.domain}")
+    print(f"     Product: {config.product}")
+    print(f"     Table: {config.table_name}")
+    print(f"     Bronze Version: {config.bronze_version}")
+    print(f"     Silver Version: {config.silver_version}")
+    print(f"     Gold Version: {config.gold_version}")
+
+    print("   ⚙️ Processing Methods:")
+    print(f"     Bronze: {config.bronze_processing_method}")
+    print(f"     Silver: {config.silver_processing_method}")
+    print(f"     Gold: {config.gold_processing_method}")
+
+    # Only show generated lake paths if structure is complete
+    if all([config.domain, config.product, config.table_name]):
+        print("   📁 Generated Paths:")
+        print(f"     Bronze Lake Path: {config.get_lake_path('bronze')}")
+        print(f"     Silver Lake Path: {config.get_lake_path('silver')}")
+        print(f"     Gold Lake Path: {config.get_lake_path('gold')}")
+        print("   📁 Work paths:")
+        print(f"     Bronze: {config.get_work_path('bronze')}")
+        print(f"     Silver: {config.get_work_path('silver')}")
+        print(f"     Gold: {config.get_work_path('gold')}")
+    else:
+        print("   ⚠️  Data Lake Structure incomplete - paths not generated")
+
+    # Infrastructure variables
+    if config.env_vars:
+        print("   🔧 Infrastructure Variables:")
+        for key, value in sorted(config.env_vars.items()):
+            display_value = value if value else "(empty)"
+            print(f"     {key}: {display_value}")

dataorc_utils-0.1.0/src/dataorc_utils.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: dataorc-utils
+Version: 0.1.0
+Summary: Utility functions for ETL operations
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.8.0; extra == "dev"

dataorc_utils-0.1.0/src/dataorc_utils.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+src/dataorc_utils/__init__.py
+src/dataorc_utils.egg-info/PKG-INFO
+src/dataorc_utils.egg-info/SOURCES.txt
+src/dataorc_utils.egg-info/dependency_links.txt
+src/dataorc_utils.egg-info/requires.txt
+src/dataorc_utils.egg-info/top_level.txt
+src/dataorc_utils/config/__init__.py
+src/dataorc_utils/config/enums.py
+src/dataorc_utils/config/manager.py
+src/dataorc_utils/config/models.py
+src/dataorc_utils/config/rules.py
+src/dataorc_utils/config/validation.py
+tests/test_config_basic.py

dataorc_utils-0.1.0/src/dataorc_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dataorc_utils-0.1.0/src/dataorc_utils.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=8.0
+pytest-cov>=7.0
+ruff>=0.8.0

dataorc_utils-0.1.0/src/dataorc_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+dataorc_utils

dataorc_utils-0.1.0/tests/test_config_basic.py

@@ -0,0 +1,114 @@
+import os
+import sys
+
+import pytest
+
+# Ensure the package src directory is on path before importing package
+CURRENT_DIR = os.path.dirname(__file__)
+SRC_ROOT = os.path.abspath(os.path.join(CURRENT_DIR, ".."))
+if SRC_ROOT not in sys.path:
+    sys.path.insert(0, SRC_ROOT)
+
+from dataorc_utils.config import (  # noqa: E402
+    CoreParam,
+    CorePipelineConfig,
+    Environment,
+    PipelineParameterManager,
+)
+
+
+def make_config(**overrides):
+    base = dict(
+        env=Environment.DEV,
+        domain="finance",
+        product="forecast",
+        table_name="positions",
+        bronze_version="v1",
+        silver_version="v2",
+        gold_version="v3",
+        bronze_processing_method="incremental",
+        silver_processing_method="full",
+        gold_processing_method="delta",
+        env_vars={
+            "datalake_name": "dlakeacct",
+            "datalake_container_name": "raw",
+        },
+    )
+    base.update(overrides)
+    return CorePipelineConfig(**base)
+
+
+def test_lake_path_bronze():
+    cfg = make_config()
+    assert (
+        cfg.get_lake_path("bronze")
+        == "raw/bronze/finance/forecast/positions/v1/output/incremental"
+    )
+
+
+def test_lake_path_silver():
+    cfg = make_config()
+    assert (
+        cfg.get_lake_path("silver")
+        == "raw/silver/finance/forecast/positions/v2/output/full"
+    )
+
+
+def test_lake_path_gold():
+    cfg = make_config()
+    assert (
+        cfg.get_lake_path("gold")
+        == "raw/gold/finance/forecast/positions/v3/output/delta"
+    )
+
+
+def test_lake_path_overrides():
+    cfg = make_config()
+    custom = cfg.get_lake_path(
+        "gold", processing_method_override="full", version_override="v9"
+    )
+    assert custom == "raw/gold/finance/forecast/positions/v9/output/full"
+
+
+def test_validate_rules_pass():
+    cfg = make_config()
+    assert cfg.validate_rules() is True
+
+
+def test_validate_rules_fail_uppercase_domain():
+    cfg = make_config(domain="Finance")
+    with pytest.raises(ValueError) as exc:
+        cfg.validate_rules()
+    assert "uppercase" in str(exc.value).lower()
+
+
+def test_validate_rules_fail_bad_version_pattern():
+    cfg = make_config(bronze_version="version1")  # missing leading 'v'
+    with pytest.raises(ValueError) as exc:
+        cfg.validate_rules()
+    assert "pattern" in str(exc.value).lower() or "v<integer>" in str(exc.value)
+
+
+def test_validate_rules_pass_custom_version_override():
+    # Overrides should not break rule when format is correct
+    cfg = make_config()
+    path = cfg.get_lake_path("bronze", version_override="v99")
+    assert path.endswith("/v99/output/incremental")
+
+
+def test_case_fallback_env_uppercase_resolution(monkeypatch):
+    """Primary fallback behavior: uppercase variant is resolved when case_fallback=True."""
+    key_upper = "DATALAKE_NAME"
+    key_lower = CoreParam.DATALAKE_NAME.value
+    for k in (key_upper, key_lower):
+        monkeypatch.delenv(k, raising=False)
+
+    # On Windows env vars are case-insensitive, but logic path still runs.
+    monkeypatch.setenv(key_upper, "LakeAcctFallback")
+    monkeypatch.setenv("DATALAKE_CONTAINER_NAME", "container-fb")
+    monkeypatch.setenv("env", Environment.DEV.value)
+
+    mgr = PipelineParameterManager(case_fallback=True)
+    infra = mgr.prepare_infrastructure(["datalake_name", "datalake_container_name"])
+    assert infra.variables.get("datalake_name") == "LakeAcctFallback"
+    assert infra.variables.get("datalake_container_name") == "container-fb"