environment-guard 0.1.0__py3-none-any.whl

env_guard/__init__.py

@@ -0,0 +1,72 @@
+"""
+env-guard: Zero-config environment variable validation.
+
+Infer types from .env.example, validate at runtime, fail fast with beautiful errors.
+"""
+
+from .validator import (
+    validate,
+    validate_env,
+    EnvValidationError,
+    EnvVar,
+    InferredType,
+    ValidationResult,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "validate",
+    "validate_env",
+    "EnvValidationError",
+    "EnvVar",
+    "InferredType",
+    "ValidationResult",
+    "__version__",
+]
+
+
+def main() -> None:
+    """CLI entry point for env-guard."""
+    import sys
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="env-guard",
+        description="Validate environment variables against .env.example",
+    )
+    parser.add_argument(
+        "-e", "--example",
+        default=".env.example",
+        help="Path to .env.example file (default: .env.example)",
+    )
+    parser.add_argument(
+        "-q", "--quiet",
+        action="store_true",
+        help="Only output errors, no success messages",
+    )
+    parser.add_argument(
+        "--no-exit",
+        action="store_true",
+        help="Don't exit with code 1 on validation failure",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        result = validate_env(example_path=args.example, exit_on_error=False)
+
+        if result.is_valid:
+            if not args.quiet:
+                print(f"\n  All {len(result.variables)} environment variables validated successfully!")
+            sys.exit(0)
+        else:
+            if not args.no_exit:
+                sys.exit(1)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)

env_guard/validator.py

@@ -0,0 +1,482 @@
+"""
+Core validation logic for env-guard.
+
+This module provides environment variable validation by:
+1. Parsing .env.example to infer expected variables and their types
+2. Checking os.environ for presence and type conformance
+3. Reporting all errors with colorized, grouped output
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from dotenv import dotenv_values
+
+
+class InferredType(Enum):
+    """Types that can be inferred from .env.example values."""
+
+    STRING = "string"
+    INTEGER = "integer"
+    FLOAT = "float"
+    BOOLEAN = "boolean"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass
+class EnvVar:
+    """Represents an environment variable specification."""
+
+    name: str
+    example_value: str
+    inferred_type: InferredType
+    optional: bool = False
+    comment: str | None = None
+
+    def validate_value(self, value: str) -> tuple[bool, str | None]:
+        """
+        Validate that a value conforms to this variable's inferred type.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if self.inferred_type == InferredType.INTEGER:
+            try:
+                int(value)
+                return True, None
+            except ValueError:
+                return False, f"expected integer, got '{value}'"
+
+        elif self.inferred_type == InferredType.FLOAT:
+            try:
+                float(value)
+                return True, None
+            except ValueError:
+                return False, f"expected float, got '{value}'"
+
+        elif self.inferred_type == InferredType.BOOLEAN:
+            if value.lower() in ("true", "false", "1", "0", "yes", "no"):
+                return True, None
+            return False, f"expected boolean (true/false/1/0/yes/no), got '{value}'"
+
+        # STRING type accepts anything
+        return True, None
+
+
+@dataclass
+class ValidationError:
+    """Represents a single validation error."""
+
+    var_name: str
+    error_type: str  # "missing" or "type_mismatch"
+    message: str
+    expected_type: InferredType | None = None
+    actual_value: str | None = None
+
+
+@dataclass
+class ValidationResult:
+    """Result of environment validation."""
+
+    is_valid: bool
+    variables: list[EnvVar]
+    errors: list[ValidationError] = field(default_factory=list)
+    validated_values: dict[str, Any] = field(default_factory=dict)
+
+
+class EnvValidationError(Exception):
+    """Raised when environment validation fails."""
+
+    def __init__(self, result: ValidationResult):
+        self.result = result
+        super().__init__(f"Environment validation failed with {len(result.errors)} error(s)")
+
+
+def infer_type(value: str) -> InferredType:
+    """
+    Infer the type of an environment variable from its example value.
+
+    Rules:
+    - Integers: digits only, optionally with leading minus
+    - Floats: digits with decimal point
+    - Booleans: true/false/yes/no (case insensitive)
+    - Everything else: string
+    """
+    if not value:
+        return InferredType.STRING
+
+    # Check for boolean
+    if value.lower() in ("true", "false", "yes", "no"):
+        return InferredType.BOOLEAN
+
+    # Check for integer (including negative)
+    if re.match(r"^-?\d+$", value):
+        return InferredType.INTEGER
+
+    # Check for float (including negative, must have decimal point)
+    if re.match(r"^-?\d+\.\d+$", value):
+        return InferredType.FLOAT
+
+    return InferredType.STRING
+
+
+def is_optional_marker(comment: str | None) -> bool:
+    """Check if a comment indicates the variable is optional."""
+    if not comment:
+        return False
+    comment_lower = comment.lower()
+    return any(marker in comment_lower for marker in ["optional", "?", "not required"])
+
+
+def parse_env_example(path: str | Path) -> list[EnvVar]:
+    """
+    Parse a .env.example file and return a list of EnvVar specifications.
+
+    Handles:
+    - Standard KEY=value pairs
+    - Comments (# ...) for optional markers
+    - Empty values
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Example file not found: {path}")
+
+    # Use dotenv to parse key-value pairs
+    values = dotenv_values(path)
+
+    # Also read raw content to extract comments
+    content = path.read_text(encoding="utf-8")
+    lines = content.splitlines()
+
+    # Build a map of variable names to their inline comments
+    var_comments: dict[str, str] = {}
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        # Check for inline comment
+        if "#" in line:
+            # Split on first = to get the key
+            if "=" in line:
+                key_part = line.split("=")[0].strip()
+                comment_part = line.split("#", 1)[1].strip() if "#" in line else ""
+                var_comments[key_part] = comment_part
+
+    env_vars = []
+    for name, value in values.items():
+        value = value or ""
+        inferred = infer_type(value)
+        comment = var_comments.get(name)
+        optional = is_optional_marker(comment)
+
+        env_vars.append(
+            EnvVar(
+                name=name,
+                example_value=value,
+                inferred_type=inferred,
+                optional=optional,
+                comment=comment,
+            )
+        )
+
+    return env_vars
+
+
+def validate_environment(
+    env_vars: list[EnvVar],
+    environ: dict[str, str] | None = None,
+) -> ValidationResult:
+    """
+    Validate environment variables against specifications.
+
+    Args:
+        env_vars: List of expected environment variables
+        environ: Environment dict to validate (defaults to os.environ)
+
+    Returns:
+        ValidationResult with status, errors, and validated values
+    """
+    if environ is None:
+        environ = dict(os.environ)
+
+    errors: list[ValidationError] = []
+    validated_values: dict[str, Any] = {}
+
+    for var in env_vars:
+        value = environ.get(var.name)
+
+        # Check if missing
+        if value is None:
+            if not var.optional:
+                errors.append(
+                    ValidationError(
+                        var_name=var.name,
+                        error_type="missing",
+                        message=f"Required variable '{var.name}' is not set",
+                        expected_type=var.inferred_type,
+                    )
+                )
+            continue
+
+        # Check type
+        is_valid, error_msg = var.validate_value(value)
+        if not is_valid:
+            errors.append(
+                ValidationError(
+                    var_name=var.name,
+                    error_type="type_mismatch",
+                    message=f"Variable '{var.name}': {error_msg}",
+                    expected_type=var.inferred_type,
+                    actual_value=value,
+                )
+            )
+        else:
+            # Store the coerced value
+            validated_values[var.name] = _coerce_value(value, var.inferred_type)
+
+    return ValidationResult(
+        is_valid=len(errors) == 0,
+        variables=env_vars,
+        errors=errors,
+        validated_values=validated_values,
+    )
+
+
+def _coerce_value(value: str, inferred_type: InferredType) -> Any:
+    """Convert a string value to its inferred type."""
+    if inferred_type == InferredType.INTEGER:
+        return int(value)
+    elif inferred_type == InferredType.FLOAT:
+        return float(value)
+    elif inferred_type == InferredType.BOOLEAN:
+        return value.lower() in ("true", "1", "yes")
+    return value
+
+
+# =============================================================================
+# Output Formatting (with optional rich support)
+# =============================================================================
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.text import Text
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+
+def _format_output_rich(result: ValidationResult) -> None:
+    """Format validation output using rich library."""
+    console = Console(stderr=True)
+
+    if result.is_valid:
+        # Success output
+        console.print()
+        text = Text()
+        text.append("  ", style="green")
+        text.append(f"All {len(result.variables)} environment variables validated successfully!", style="green bold")
+        console.print(Panel(text, border_style="green", title="env-guard"))
+        console.print()
+        return
+
+    # Error output
+    console.print()
+    console.print(Panel(
+        f"[red bold]Environment validation failed with {len(result.errors)} error(s)[/]",
+        border_style="red",
+        title="env-guard",
+    ))
+    console.print()
+
+    # Group errors by type
+    missing = [e for e in result.errors if e.error_type == "missing"]
+    type_errors = [e for e in result.errors if e.error_type == "type_mismatch"]
+
+    if missing:
+        table = Table(title="Missing Variables", border_style="red", title_style="red bold")
+        table.add_column("Variable", style="cyan")
+        table.add_column("Expected Type", style="yellow")
+
+        for error in missing:
+            table.add_row(error.var_name, str(error.expected_type))
+
+        console.print(table)
+        console.print()
+
+    if type_errors:
+        table = Table(title="Type Mismatches", border_style="red", title_style="red bold")
+        table.add_column("Variable", style="cyan")
+        table.add_column("Expected", style="yellow")
+        table.add_column("Got", style="red")
+
+        for error in type_errors:
+            table.add_row(
+                error.var_name,
+                str(error.expected_type),
+                repr(error.actual_value),
+            )
+
+        console.print(table)
+        console.print()
+
+    # Hint
+    console.print("[dim]Hint: Set missing variables or fix type mismatches in your environment.[/]")
+    console.print()
+
+
+def _format_output_plain(result: ValidationResult) -> None:
+    """Format validation output using ANSI codes (no rich dependency)."""
+    # ANSI color codes
+    RED = "\033[91m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    CYAN = "\033[96m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    RESET = "\033[0m"
+
+    if result.is_valid:
+        print(file=sys.stderr)
+        print(f"{GREEN}{BOLD}  All {len(result.variables)} environment variables validated successfully!{RESET}", file=sys.stderr)
+        print(file=sys.stderr)
+        return
+
+    # Error output
+    print(file=sys.stderr)
+    print(f"{RED}{BOLD}=== env-guard: Validation Failed ==={RESET}", file=sys.stderr)
+    print(f"{RED}Found {len(result.errors)} error(s){RESET}", file=sys.stderr)
+    print(file=sys.stderr)
+
+    # Group errors by type
+    missing = [e for e in result.errors if e.error_type == "missing"]
+    type_errors = [e for e in result.errors if e.error_type == "type_mismatch"]
+
+    if missing:
+        print(f"{RED}{BOLD}Missing Variables:{RESET}", file=sys.stderr)
+        for error in missing:
+            print(f"  {CYAN}{error.var_name}{RESET} - expected {YELLOW}{error.expected_type}{RESET}", file=sys.stderr)
+        print(file=sys.stderr)
+
+    if type_errors:
+        print(f"{RED}{BOLD}Type Mismatches:{RESET}", file=sys.stderr)
+        for error in type_errors:
+            print(
+                f"  {CYAN}{error.var_name}{RESET}: expected {YELLOW}{error.expected_type}{RESET}, "
+                f"got {RED}{repr(error.actual_value)}{RESET}",
+                file=sys.stderr
+            )
+        print(file=sys.stderr)
+
+    print(f"{DIM}Hint: Set missing variables or fix type mismatches in your environment.{RESET}", file=sys.stderr)
+    print(file=sys.stderr)
+
+
+def print_validation_result(result: ValidationResult, use_rich: bool | None = None) -> None:
+    """
+    Print validation result with colorized output.
+
+    Args:
+        result: The validation result to display
+        use_rich: Force rich (True) or plain (False) output. None = auto-detect.
+    """
+    if use_rich is None:
+        use_rich = RICH_AVAILABLE
+
+    if use_rich and RICH_AVAILABLE:
+        _format_output_rich(result)
+    else:
+        _format_output_plain(result)
+
+
+# =============================================================================
+# Public API
+# =============================================================================
+
+def validate_env(
+    example_path: str | Path = ".env.example",
+    exit_on_error: bool = True,
+    use_rich: bool | None = None,
+    quiet: bool = False,
+) -> ValidationResult:
+    """
+    Validate environment variables against a .env.example file.
+
+    This is the main entry point for most users.
+
+    Args:
+        example_path: Path to the .env.example file
+        exit_on_error: If True, calls sys.exit(1) on validation failure
+        use_rich: Force rich (True) or plain (False) output. None = auto-detect.
+        quiet: If True, suppress all output (useful for programmatic use)
+
+    Returns:
+        ValidationResult object
+
+    Raises:
+        FileNotFoundError: If the example file doesn't exist
+        SystemExit: If validation fails and exit_on_error is True
+
+    Example:
+        >>> from env_guard import validate_env
+        >>> result = validate_env()  # Uses .env.example by default
+    """
+    env_vars = parse_env_example(example_path)
+    result = validate_environment(env_vars)
+
+    if not quiet:
+        print_validation_result(result, use_rich=use_rich)
+
+    if not result.is_valid and exit_on_error:
+        sys.exit(1)
+
+    return result
+
+
+def validate(
+    example_path: str | Path = ".env.example",
+    environ: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    """
+    Validate and return typed environment values.
+
+    A more Pythonic alternative that returns the validated values directly
+    or raises an exception on failure.
+
+    Args:
+        example_path: Path to the .env.example file
+        environ: Environment dict to validate (defaults to os.environ)
+
+    Returns:
+        Dictionary of variable names to their typed values
+
+    Raises:
+        FileNotFoundError: If the example file doesn't exist
+        EnvValidationError: If validation fails
+
+    Example:
+        >>> from env_guard import validate
+        >>> env = validate()
+        >>> print(env["PORT"])  # Already an int!
+        8000
+    """
+    env_vars = parse_env_example(example_path)
+    result = validate_environment(env_vars, environ)
+
+    if not result.is_valid:
+        print_validation_result(result)
+        raise EnvValidationError(result)
+
+    return result.validated_values

environment_guard-0.1.0.dist-info/METADATA

@@ -0,0 +1,352 @@
+Metadata-Version: 2.4
+Name: environment-guard
+Version: 0.1.0
+Summary: Zero-config environment variable validation - infer types from .env.example, validate at runtime
+Project-URL: Homepage, https://github.com/ljo3/env-guard
+Project-URL: Documentation, https://github.com/ljo3/env-guard#readme
+Project-URL: Repository, https://github.com/ljo3/env-guard
+Project-URL: Issues, https://github.com/ljo3/env-guard/issues
+Author-email: Your Name <your.email@example.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: config,configuration,dotenv,env,environment,type-checking,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: rich>=13.0.0; extra == 'dev'
+Requires-Dist: twine>=4.0.0; extra == 'dev'
+Provides-Extra: rich
+Requires-Dist: rich>=13.0.0; extra == 'rich'
+Description-Content-Type: text/markdown
+
+# env-guard
+
+**Zero-config environment variable validation for Python.**
+
+Stop writing boilerplate. Your `.env.example` already documents your config — let it validate too.
+
+## Why env-guard?
+
+Most environment validation libraries require you to define your schema twice:
+
+```python
+# With Pydantic Settings (the old way)
+class Settings(BaseSettings):
+    PORT: int
+    DEBUG: bool = False
+    DATABASE_URL: str
+    API_KEY: str
+    REDIS_HOST: str = "localhost"
+    REDIS_PORT: int = 6379
+```
+
+But you already have this information in `.env.example`:
+
+```bash
+PORT=8000
+DEBUG=false
+DATABASE_URL=postgresql://localhost/myapp
+API_KEY=your-api-key-here
+REDIS_HOST=localhost
+REDIS_PORT=6379
+```
+
+**Why write it twice?**
+
+With env-guard, you don't. One line validates everything:
+
+```python
+from env_guard import validate_env
+
+validate_env()  # That's it. Zero config.
+```
+
+## Features
+
+- **Zero configuration** — Types are inferred from `.env.example` values
+- **Fail fast** — All errors reported at once with beautiful output
+- **Type coercion** — Get typed values (`int`, `bool`, `float`, `str`)
+- **Optional variables** — Mark with `# optional` comment
+- **Rich output** — Colorized error reports (with fallback for minimal installs)
+- **CI-friendly** — Exit code 1 on failure, works in any pipeline
+
+## Installation
+
+```bash
+pip install environment-guard
+```
+
+For colorized output with Rich:
+
+```bash
+pip install environment-guard[rich]
+```
+
+## Quick Start
+
+### 1. Create your `.env.example`
+
+```bash
+# .env.example
+PORT=8000
+DEBUG=false
+DATABASE_URL=postgresql://localhost/myapp
+API_KEY=your-secret-key
+WEBHOOK_URL=https://example.com/hook  # optional
+```
+
+### 2. Validate on startup
+
+```python
+# app.py
+from env_guard import validate_env
+
+# Validates against .env.example, exits with code 1 on failure
+validate_env()
+
+# Your app starts here...
+```
+
+### 3. Get typed values (optional)
+
+```python
+from env_guard import validate
+
+env = validate()
+
+print(env["PORT"])        # 8000 (int, not str!)
+print(env["DEBUG"])       # False (bool)
+print(env["DATABASE_URL"]) # "postgresql://..." (str)
+```
+
+## Type Inference Rules
+
+env-guard infers types from your example values:
+
+| Example Value | Inferred Type |
+|---------------|---------------|
+| `8000` | `int` |
+| `3.14` | `float` |
+| `true`, `false`, `yes`, `no` | `bool` |
+| Everything else | `str` |
+
+## Optional Variables
+
+Mark variables as optional with a comment:
+
+```bash
+REQUIRED_VAR=value
+OPTIONAL_VAR=default  # optional
+ALSO_OPTIONAL=123     # ?
+NOT_REQUIRED=true     # not required
+```
+
+Optional variables won't cause validation failures if missing.
+
+## API Reference
+
+### `validate_env()`
+
+Main validation function. Prints results and exits on failure.
+
+```python
+from env_guard import validate_env
+
+result = validate_env(
+    example_path=".env.example",  # Path to example file
+    exit_on_error=True,           # Exit with code 1 on failure
+    quiet=False,                  # Suppress output
+)
+```
+
+### `validate()`
+
+Returns typed values or raises `EnvValidationError`.
+
+```python
+from env_guard import validate, EnvValidationError
+
+try:
+    env = validate()
+    port = env["PORT"]  # Already an int!
+except EnvValidationError as e:
+    print(f"Missing: {[err.var_name for err in e.result.errors]}")
+```
+
+### CLI
+
+```bash
+# Validate using .env.example in current directory
+env-guard
+
+# Specify a different file
+env-guard -e config/.env.example
+
+# Quiet mode (only show errors)
+env-guard -q
+
+# Don't exit with error code (useful for scripts)
+env-guard --no-exit
+```
+
+## Error Output
+
+When validation fails, you get a clear, grouped error report:
+
+```
+╭─────────────────────────────────────────────────────────────╮
+│ Environment validation failed with 3 error(s)              │
+╰─────────────────────────────────────────────────────────────╯
+
+┏━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
+┃ Missing Variables               ┃
+┣━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━┫
+┃ Variable        ┃ Expected Type┃
+┣━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━┫
+┃ API_KEY         ┃ string       ┃
+┃ DATABASE_URL    ┃ string       ┃
+┗━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━┛
+
+┏━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+┃ Type Mismatches                              ┃
+┣━━━━━━━━━━━━━━━━━╋━━━━━━━━━━╋━━━━━━━━━━━━━━━┫
+┃ Variable        ┃ Expected ┃ Got           ┃
+┣━━━━━━━━━━━━━━━━━╋━━━━━━━━━━╋━━━━━━━━━━━━━━━┫
+┃ PORT            ┃ integer  ┃ 'not-a-port'  ┃
+┗━━━━━━━━━━━━━━━━━┻━━━━━━━━━━┻━━━━━━━━━━━━━━━┛
+
+Hint: Set missing variables or fix type mismatches in your environment.
+```
+
+## Integration Examples
+
+### FastAPI
+
+```python
+# main.py
+from fastapi import FastAPI
+from env_guard import validate
+
+# Validate before app creation
+env = validate()
+
+app = FastAPI()
+
+@app.get("/")
+def root():
+    return {"port": env["PORT"], "debug": env["DEBUG"]}
+```
+
+### Flask
+
+```python
+# app.py
+from flask import Flask
+from env_guard import validate_env
+
+validate_env()  # Fails fast if env is misconfigured
+
+app = Flask(__name__)
+```
+
+### Django
+
+```python
+# settings.py
+from env_guard import validate
+
+env = validate()
+
+DEBUG = env["DEBUG"]
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.postgresql",
+        "NAME": env["DATABASE_NAME"],
+    }
+}
+```
+
+### Docker / CI
+
+```dockerfile
+# Dockerfile
+FROM python:3.12-slim
+COPY . /app
+WORKDIR /app
+RUN pip install .
+# Validate env before starting
+CMD ["sh", "-c", "env-guard && python main.py"]
+```
+
+```yaml
+# GitHub Actions
+- name: Validate environment
+  run: env-guard
+  env:
+    PORT: 8000
+    DEBUG: false
+    API_KEY: ${{ secrets.API_KEY }}
+```
+
+## Comparison
+
+| Feature | env-guard | pydantic-settings | environs |
+|---------|-----------|-------------------|----------|
+| Zero config | ✅ | ❌ | ❌ |
+| Type inference | ✅ | ❌ | ❌ |
+| Single source of truth | ✅ | ❌ | ❌ |
+| Grouped error output | ✅ | ❌ | ❌ |
+| No dependencies* | ✅ | ❌ | ❌ |
+| Typed return values | ✅ | ✅ | ✅ |
+| Nested config | ❌ | ✅ | ✅ |
+| Complex validation | ❌ | ✅ | ✅ |
+
+*Only requires `python-dotenv`. Rich is optional.
+
+## When NOT to Use env-guard
+
+env-guard is designed for simplicity. If you need:
+
+- **Complex validation rules** (regex, min/max, custom validators)
+- **Nested configuration** (YAML-style hierarchies)
+- **Multiple environment files** (.env.local, .env.production)
+- **Secret management integration** (AWS Secrets Manager, etc.)
+
+Consider [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) or [dynaconf](https://www.dynaconf.com/) instead.
+
+## Contributing
+
+Contributions welcome! Please read our contributing guidelines first.
+
+```bash
+# Clone and install dev dependencies
+git clone https://github.com/ljo3/env-guard.git
+cd env-guard
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=env_guard
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

environment_guard-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+env_guard/__init__.py,sha256=ukkjbrvkhnuicjw4v2ZumnM0xsK48nvqvRYrXN5hfQo,1756
+env_guard/validator.py,sha256=9Qadp3omFu1WLSITr2LFqWHcTCWkdpmagTVdXZwZQZE,14586
+environment_guard-0.1.0.dist-info/METADATA,sha256=TBEWSxHOgGrmg1f3zRVwi6WzILUBZ1aFzBtbTUNa9oc,9437
+environment_guard-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+environment_guard-0.1.0.dist-info/entry_points.txt,sha256=-2LE4AmMxmwr46ZKuyEBYwEM08Mhhf4lzSXflMZt9WM,45
+environment_guard-0.1.0.dist-info/licenses/LICENSE,sha256=F-4b93u0OVrVwGXgMwBRq6MlGyUT9zmre1oh5Gft5Ts,1066
+environment_guard-0.1.0.dist-info/RECORD,,

environment_guard-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

environment_guard-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+env-guard = env_guard:main

environment_guard-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.