{"id":35313411,"url":"https://github.com/lzjever/varlord","last_synced_at":"2026-01-17T16:27:51.509Z","repository":{"id":331447167,"uuid":"1125356114","full_name":"lzjever/varlord","owner":"lzjever","description":"Unified yet dead simple Python config management: defaults, CLI, env vars, .env, etcd. Type-safe, validated, with dynamic updates.","archived":false,"fork":false,"pushed_at":"2026-01-15T06:09:42.000Z","size":524,"stargazers_count":36,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-01-17T04:24:01.544Z","etag":null,"topics":["cli-args","config-management","configuration","dotenv","environment-variables","etcd","multi-source","priority","python","settings","validation"],"latest_commit_sha":null,"homepage":"https://varlord.readthedocs.io","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/lzjever.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-12-30T15:26:12.000Z","updated_at":"2026-01-15T06:01:14.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/lzjever/varlord","commit_stats":null,"previous_names":["lzjever/varlord"],"tags_count":10,"template":false,"template_full_name":null,"purl":"pkg:github/lzjever/varlord","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/lzjever%2Fvarlord","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/lzjever%2Fvarlord/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/lzjever%2Fvarlord/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/lzjever%2Fvarlord/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/lzjever","download_url":"https://codeload.github.com/lzjever/varlord/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/lzjever%2Fvarlord/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28511864,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-17T13:38:16.342Z","status":"ssl_error","status_checked_at":"2026-01-17T13:37:44.060Z","response_time":85,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cli-args","config-management","configuration","dotenv","environment-variables","etcd","multi-source","priority","python","settings","validation"],"created_at":"2025-12-30T18:05:25.165Z","updated_at":"2026-01-17T16:27:51.487Z","avatar_url":"https://github.com/lzjever.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Varlord ⚙️\n\n[![PyPI version](https://img.shields.io/pypi/v/varlord.svg)](https://pypi.org/project/varlord/)\n[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)\n[![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)\n[![Documentation](https://readthedocs.org/projects/varlord/badge/?version=latest)](https://varlord.readthedocs.io)\n[![CI](https://github.com/lzjever/varlord/workflows/CI/badge.svg)](https://github.com/lzjever/varlord/actions)\n[![codecov](https://codecov.io/gh/lzjever/varlord/branch/main/graph/badge.svg)](https://codecov.io/gh/lzjever/varlord)\n\n\u003e **Stop wrestling with configuration chaos. Start with Varlord.**\n\n**Varlord** is a battle-tested Python configuration management library that eliminates the pain of managing configuration from multiple sources. Born from real-world production challenges, it provides a **unified, type-safe, and elegant** solution for configuration management.\n\n## 🎯 The Problem We Solve\n\n### Real-World Configuration Nightmares\n\nEvery Python developer has faced these frustrating scenarios:\n\n#### ❌ **The Configuration Spaghetti**\n```python\n# Your code becomes a mess of conditionals and parsing\nhost = os.getenv(\"HOST\", \"127.0.0.1\")\nport = int(os.getenv(\"PORT\", \"8000\"))  # What if PORT is not a number?\ndebug = os.getenv(\"DEBUG\", \"false\").lower() == \"true\"  # Really?\nif \"--host\" in sys.argv:\n    host = sys.argv[sys.argv.index(\"--host\") + 1]  # Error-prone parsing\n# ... and it gets worse with nested configs, validation, etc.\n```\n\n#### ❌ **Priority Confusion**\n\u003e \"Does CLI override env? Or env overrides CLI? Wait, what about the config file? Which one wins?\"\n\n#### ❌ **Type Conversion Hell**\n```python\n# String \"true\" vs boolean True vs \"1\" vs 1\n# \"8000\" vs 8000\n# Missing values, None handling, type errors at runtime...\n```\n\n#### ❌ **The Restart Tax**\n\u003e \"I just need to change one config value. Why do I have to restart the entire service?\"\n\n#### ❌ **Silent Failures**\n\u003e \"The config looks wrong, but the app starts anyway. Users report bugs 3 hours later.\"\n\n### ✅ **Varlord's Solution**\n\n**One unified interface. Multiple sources. Clear priority. Built-in diagnostics.**\n\n```python\nfrom dataclasses import dataclass, field\nfrom pathlib import Path\nfrom typing import Optional\nfrom varlord import Config, sources\n\n@dataclass(frozen=True)\nclass AppConfig:\n    \"\"\"Application configuration with clear structure and validation.\"\"\"\n    \n    # Required field - must be provided\n    api_key: str = field(metadata={\"description\": \"API key for authentication\"})\n    \n    # Optional fields with sensible defaults\n    host: str = field(default=\"127.0.0.1\", metadata={\"description\": \"Server host address\"})\n    port: int = field(default=8000, metadata={\"description\": \"Server port number\"})\n    debug: bool = field(default=False, metadata={\"description\": \"Enable debug mode\"})\n    timeout: float = field(default=30.0, metadata={\"description\": \"Request timeout in seconds\"})\n    hello_message: Optional[str] = field(\n        default=None, metadata={\"description\": \"Optional greeting message\"}\n    )\n\ndef main():\n    # Define configuration sources with clear priority order\n    # Priority: CLI (highest) \u003e User Config \u003e App Config \u003e System Config \u003e Env \u003e Defaults (lowest)\n    cfg = Config(\n        model=AppConfig,\n        sources=[\n            # System-wide configuration (lowest priority, rarely overridden)\n            sources.YAML(\"/etc/myapp/config.yaml\"),  # System config\n            \n            # Application-level configuration\n            sources.JSON(Path(__file__).parent / \"config.json\"),  # App directory\n            \n            # User-specific configuration (overrides system and app configs)\n            sources.YAML(Path.home() / \".config\" / \"myapp\" / \"config.yaml\"),  # User directory\n            sources.TOML(Path.home() / \".myapp.toml\"),  # Alternative user config\n            \n            # Environment variables (common in containers/CI)\n            sources.Env(),\n            sources.DotEnv(\".env\"),  # Local development\n            \n            # Command-line arguments (highest priority, for debugging/overrides)\n            sources.CLI(),\n        ],\n    )\n    \n    # One line to add comprehensive CLI management: --help, --check-variables, etc.\n    # This single call adds:\n    #   - --help / -h: Auto-generated help from your model metadata\n    #   - --check-variables / -cv: Complete configuration diagnostics\n    #   - Automatic validation and error reporting\n    #   - Exit handling (exits if help/cv is requested)\n    cfg.handle_cli_commands()  # Handles --help, -cv automatically, exits if needed\n    \n    # Load configuration - type-safe, validated, ready to use\n    app = cfg.load()\n    \n    # Your application code\n    print(f\"Starting server on {app.host}:{app.port}\")\n    print(f\"Debug: {app.debug}, Timeout: {app.timeout}s\")\n\nif __name__ == \"__main__\":\n    main()\n```\n\n**What just happened?**\n\n1. **✅ Multiple Sources, Unified Interface**: System config, app config, user config, env vars, CLI - all handled the same way\n2. **✅ Clear Priority**: Later sources override earlier ones - no confusion\n3. **✅ Automatic Type Conversion**: Strings from files/env → proper types (int, bool, float)\n4. **✅ Model-Driven Filtering**: Each source only reads fields defined in your model\n5. **✅ Built-in Diagnostics**: `--check-variables` shows exactly what's loaded from where\n6. **✅ Zero Boilerplate**: No parsing, no type conversion code, no priority logic\n\n**Try it:**\n\n```bash\n# See comprehensive configuration diagnostics\npython app.py --check-variables\n# or short form\npython app.py -cv\n\n# See help with all sources and priority\npython app.py --help\n\n# Run normally\npython app.py --api-key your_key\n```\n\n**The `--check-variables` output shows everything:**\n\nWhen you run `python app.py -cv`, you get a comprehensive diagnostic report:\n\n```\n+---------------+----------+---------------+----------+-----------+\n| Variable      | Required | Status        | Source   | Value     |\n+---------------+----------+---------------+----------+-----------+\n| api_key       | Required | Missing       | defaults | None      |\n| host          | Optional | Loaded        | dotenv   | localhost |\n| port          | Optional | Loaded        | dotenv   | 7000      |\n| debug         | Optional | Loaded        | dotenv   | true      |\n| timeout       | Optional | Loaded        | dotenv   | 20.0      |\n| hello_message | Optional | Using Default | defaults | None      |\n+---------------+----------+---------------+----------+-----------+\n\nConfiguration Source Priority and Details:\n\n+------------+-------------+-----------+----------------------------------------+--------+----------------+---------------+-------------+\n| Priority   | Source Name | Source ID | Instance                               | Status | Load Time (ms) | Watch Support | Last Update |\n+------------+-------------+-----------+----------------------------------------+--------+----------------+---------------+-------------+\n| 1 (lowest) | defaults    | defaults  | \u003cDefaults(model=AppConfig)\u003e            | Active | 0.00           | No            | N/A         |\n| 2          | yaml        | yaml      | \u003cYAML(/etc/myapp/config.yaml)\u003e         | Active | 0.15           | No            | N/A         |\n| 3          | json        | json      | \u003cJSON(config.json)\u003e                    | Active | 0.08           | No            | N/A         |\n| 4          | yaml        | yaml      | \u003cYAML(~/.config/myapp/config.yaml)\u003e    | Active | 0.12           | No            | N/A         |\n| 5          | toml        | toml      | \u003cTOML(~/.myapp.toml)\u003e                  | Active | 0.05           | No            | N/A         |\n| 6          | env         | env       | \u003cEnv(model-based)\u003e                     | Active | 0.05           | No            | N/A         |\n| 7          | dotenv      | dotenv    | \u003cDotEnv(.env)\u003e                         | Active | 0.03           | No            | N/A         |\n| 8 (highest)| cli         | cli       | \u003cCLI()\u003e                                | Active | 0.20           | No            | N/A         |\n+------------+-------------+-----------+----------------------------------------+--------+----------------+---------------+-------------+\n\n\nNote: Later sources override earlier ones (higher priority).\n\n⚠️  Missing required fields: api_key\n   Exiting with code 1. Please provide these fields and try again.\n   For help, run: python app.py --help\n```\n\n**What this tells you:**\n\n- **Variable Status**: See which fields are required vs optional, loaded vs missing\n- **Source Tracking**: Know exactly which source (defaults/env/cli/file) provided each value\n- **Priority Order**: Understand the resolution chain - later sources override earlier\n- **Performance**: Load times for each source (useful for optimization)\n- **Validation**: Missing required fields are caught immediately with clear error messages\n\n**Key Benefits:**\n\n- **🔍 Complete Visibility**: See exactly which source provides each value - no more guessing where config comes from\n- **📊 Priority Visualization**: Understand the resolution order at a glance - see which source wins for each field\n- **⚡ Performance Metrics**: Load times for each source - identify slow config sources\n- **🛡️ Validation**: Missing required fields are caught before app starts - fail fast with clear errors\n- **📝 Self-Documenting**: Help text generated from your model metadata - no manual documentation needed\n- **🎯 Zero Configuration**: `handle_cli_commands()` adds all this with one line - no boilerplate\n\n**Real-World Scenarios:**\n\n- **Debugging**: \"Why is my app using the wrong port?\" → `python app.py -cv` shows port comes from env, not CLI\n- **Onboarding**: New team member runs `python app.py --help` → sees all config options with descriptions\n- **CI/CD**: Missing required field? → `-cv` shows exactly what's missing before deployment fails\n- **Multi-Environment**: See which config file (system/user/app) is actually being used\n\n**That's it.** No parsing, no type conversion, no priority confusion. Just clean, type-safe configuration with built-in diagnostics.\n\n---\n\n## 🌟 Why Varlord?\n\n### 🎯 **Core Value Propositions**\n\n| Problem | Varlord Solution | Impact |\n|---------|-----------------|--------|\n| **Config scattered everywhere** | Unified interface for all sources | Single source of truth |\n| **Priority confusion** | Simple rule: later sources override earlier | Predictable behavior |\n| **Type conversion errors** | Automatic conversion with validation | Catch errors early |\n| **No runtime updates** | Optional etcd watch for dynamic updates | Zero-downtime config changes |\n| **Repetitive boilerplate** | Model-driven, auto-filtering | 90% less code |\n| **Silent failures** | Built-in validation framework | Fail fast, fail clear |\n\n### 💡 **Key Differentiators**\n\n1. **🎯 Model-Driven Design**: Define your config once as a dataclass, and Varlord handles the rest\n2. **🔄 Smart Auto-Filtering**: Sources automatically filter by model fields - no prefix management needed\n3. **⚡ Zero Boilerplate**: Model defaults are automatic, model is auto-injected to sources\n4. **🛡️ Type Safety First**: Full type hints support with automatic conversion and validation\n5. **🚀 Production Ready**: Thread-safe, fail-safe, battle-tested in production environments\n\n---\n\n## 🚀 Quick Start\n\n### Installation\n\n```bash\npip install varlord\n\n# With optional features\npip install varlord[dotenv,etcd]\n```\n\n### Basic Usage (30 seconds)\n\n```python\nfrom dataclasses import dataclass, field\nfrom varlord import Config, sources\n\n@dataclass(frozen=True)\nclass AppConfig:\n    host: str = field(default=\"127.0.0.1\")\n    port: int = field(default=8000)\n    debug: bool = field(default=False)\n\n# Create config - that's it!\ncfg = Config(\n    model=AppConfig,\n    sources=[\n        sources.Env(),   # Reads HOST, PORT, DEBUG from environment\n        sources.CLI(),   # Reads --host, --port, --debug from CLI\n    ],\n)\n\napp = cfg.load()  # Type-safe, validated config object\nprint(f\"Server: {app.host}:{app.port}, Debug: {app.debug}\")\n```\n\n**Run it:**\n```bash\n# Use defaults\npython app.py\n# Output: Server: 127.0.0.1:8000, Debug: False\n\n# Override with env\nexport HOST=0.0.0.0 PORT=9000\npython app.py\n# Output: Server: 0.0.0.0:9000, Debug: False\n\n# Override with CLI (highest priority)\npython app.py --host 192.168.1.1 --port 8080 --debug\n# Output: Server: 192.168.1.1:8080, Debug: True\n```\n\n### One-Liner Convenience Method\n\n```python\n# Even simpler for common cases\ncfg = Config.from_model(AppConfig, cli=True, dotenv=\".env\")\napp = cfg.load()\n```\n\n---\n\n## 💼 Real-World Use Cases\n\n### Use Case 1: Microservice Configuration\n\n**Problem**: Your microservice needs config from multiple sources, and you're tired of writing parsing code.\n\n**Solution**:\n```python\n@dataclass(frozen=True)\nclass ServiceConfig:\n    db_host: str = field(default=\"localhost\")\n    db_port: int = field(default=5432)\n    api_key: str = field()  # Required - must be provided\n    log_level: str = field(default=\"INFO\")\n    max_workers: int = field(default=4)\n\ncfg = Config(\n    model=ServiceConfig,\n    sources=[\n        sources.Env(),           # Production: from environment\n        sources.DotEnv(\".env\"),  # Development: from .env file\n        sources.CLI(),           # Override: from command line\n    ],\n)\n\nconfig = cfg.load()  # Validated, type-safe, ready to use\n```\n\n**Benefits**:\n- ✅ Same code works in dev (`.env`), staging (env vars), and prod (env vars)\n- ✅ CLI overrides for debugging: `python service.py --log-level DEBUG`\n- ✅ Type safety: `max_workers` is always an `int`, never a string\n- ✅ Validation: Missing `api_key` fails fast with clear error\n\n### Use Case 2: Dynamic Configuration Updates\n\n**Problem**: You need to change configuration without restarting the service.\n\n**Solution**:\n```python\ndef on_config_change(new_config, diff):\n    print(f\"Config updated: {diff}\")\n    # Update your app's behavior based on new config\n\ncfg = Config(\n    model=AppConfig,\n    sources=[\n        sources.Env(),\n        sources.Etcd(\n            host=\"etcd.example.com\",\n            prefix=\"/app/config/\",\n            watch=True,  # Enable dynamic updates\n        ),\n    ],\n)\n\nstore = cfg.load_store()  # Returns ConfigStore for dynamic updates\nstore.subscribe(on_config_change)\n\n# Thread-safe access to current config\ncurrent = store.get()\n```\n\n**Benefits**:\n- ✅ Zero-downtime configuration updates\n- ✅ Thread-safe concurrent access\n- ✅ Automatic validation on updates\n- ✅ Change notifications via callbacks\n\n### Use Case 3: Multi-Environment Deployment\n\n**Problem**: Different configs for dev, staging, and production, but you want one codebase.\n\n**Solution**:\n```python\n# Development: .env file\n# Staging: Environment variables\n# Production: etcd + environment variables\n\ncfg = Config(\n    model=AppConfig,\n    sources=[\n        sources.DotEnv(\".env\"),  # Dev only (file may not exist in prod)\n        sources.Env(),            # All environments\n        sources.Etcd.from_env() if os.getenv(\"ETCD_HOST\") else None,  # Prod only\n        sources.CLI(),           # Override for debugging\n    ],\n)\n```\n\n**Benefits**:\n- ✅ One codebase, multiple environments\n- ✅ Environment-specific sources automatically handled\n- ✅ Clear priority: CLI \u003e etcd \u003e env \u003e .env \u003e defaults\n\n### Use Case 4: Complex Nested Configuration\n\n**Problem**: Your config has nested structures (database, cache, API keys, etc.).\n\n**Solution**:\n```python\n@dataclass(frozen=True)\nclass DatabaseConfig:\n    host: str = field(default=\"localhost\")\n    port: int = field(default=5432)\n    name: str = field(default=\"mydb\")\n\n@dataclass(frozen=True)\nclass AppConfig:\n    db: DatabaseConfig = field(default_factory=DatabaseConfig)\n    api_key: str = field()\n    cache_ttl: int = field(default=3600)\n\ncfg = Config(\n    model=AppConfig,\n    sources=[\n        sources.Env(),  # Reads DB__HOST, DB__PORT, DB__NAME automatically\n        sources.CLI(),  # Reads --db-host, --db-port, etc.\n    ],\n)\n\nconfig = cfg.load()\n# Access: config.db.host, config.db.port, config.api_key\n```\n\n**Benefits**:\n- ✅ Automatic nested key mapping (`DB__HOST` → `db.host`)\n- ✅ Type-safe nested access\n- ✅ Validation at all levels\n\n---\n\n## 🎨 Key Features\n\n### 1. **Multiple Sources, Unified Interface**\n\n```python\nsources = [\n    sources.Defaults(),      # From model defaults (automatic)\n    sources.Env(),           # From environment variables\n    sources.CLI(),           # From command-line arguments\n    sources.DotEnv(\".env\"),  # From .env files\n    sources.YAML(\"config.yaml\"),  # From YAML files\n    sources.TOML(\"config.toml\"),  # From TOML files\n    sources.Etcd(...),       # From etcd (optional)\n]\n```\n\n### 2. **Simple Priority Rule**\n\n\u003e **Later sources override earlier ones. That's it.**\n\n```python\ncfg = Config(\n    model=AppConfig,\n    sources=[\n        sources.Env(),   # Priority 1 (lowest)\n        sources.CLI(),   # Priority 2 (highest - overrides env)\n    ],\n)\n```\n\n### 3. **Automatic Type Conversion**\n\n```python\n# Environment variables are strings, but Varlord converts them automatically\nexport PORT=9000 DEBUG=true TIMEOUT=30.5\n\n@dataclass(frozen=True)\nclass Config:\n    port: int = 8000        # \"9000\" → 9000\n    debug: bool = False     # \"true\" → True\n    timeout: float = 30.0   # \"30.5\" → 30.5\n```\n\n### 4. **Model-Driven Filtering**\n\n```python\n# Your model defines what config you need\n@dataclass(frozen=True)\nclass Config:\n    host: str = \"127.0.0.1\"\n    port: int = 8000\n    # ... only these fields\n\n# Sources automatically filter - no prefix management needed\n# Env source only reads HOST and PORT, ignores everything else\n# CLI source only parses --host and --port, ignores other args\n```\n\n### 5. **Built-in Validation**\n\n```python\nfrom varlord.validators import validate_range, validate_regex\n\n@dataclass(frozen=True)\nclass Config:\n    port: int = field(default=8000)\n    host: str = field(default=\"127.0.0.1\")\n    \n    def __post_init__(self):\n        validate_range(self.port, min=1, max=65535)\n        validate_regex(self.host, r'^\\d+\\.\\d+\\.\\d+\\.\\d+$')\n```\n\n### 6. **Dynamic Updates (Optional)**\n\n```python\nstore = cfg.load_store()  # Enable watch if sources support it\nstore.subscribe(lambda new_config, diff: print(f\"Updated: {diff}\"))\n\n# Config updates automatically in background\n# Thread-safe access: current = store.get()\n```\n\n---\n\n## 📚 Documentation\n\n- **📖 Full Documentation**: [https://varlord.readthedocs.io](https://varlord.readthedocs.io)\n- **🚀 Quick Start Guide**: [Quick Start](https://varlord.readthedocs.io/en/latest/user_guide/quickstart.html)\n- **💡 Examples**: [Examples Directory](examples/)\n- **🎯 API Reference**: [API Documentation](https://varlord.readthedocs.io/en/latest/api/index.html)\n\n---\n\n## 🧠 Memory Aids (Quick Reference)\n\n### The Varlord Mantra\n\n\u003e **\"Define once, use everywhere. Later overrides earlier. Types are automatic.\"**\n\n### Priority Cheat Sheet\n\n```\nDefaults \u003c .env \u003c Environment \u003c YAML/TOML \u003c etcd \u003c CLI\n  (lowest priority)                          (highest priority)\n```\n\n### Common Patterns\n\n```python\n# Pattern 1: Simple (most common)\nConfig(model=AppConfig, sources=[sources.Env(), sources.CLI()])\n\n# Pattern 2: With .env file\nConfig(model=AppConfig, sources=[sources.DotEnv(\".env\"), sources.Env(), sources.CLI()])\n\n# Pattern 3: Dynamic updates\nConfig(model=AppConfig, sources=[sources.Env(), sources.Etcd(..., watch=True)])\nstore = cfg.load_store()\n\n# Pattern 4: One-liner\nConfig.from_model(AppConfig, cli=True, dotenv=\".env\")\n```\n\n---\n\n## 🏢 Production Proven\n\n**Varlord** is part of the **Agentsmith** ecosystem, battle-tested in production environments:\n\n- ✅ Deployed in multiple highway management companies\n- ✅ Used by securities firms and regulatory agencies\n- ✅ Handles high-throughput microservices\n- ✅ Thread-safe and production-ready\n\n### 🌟 Agentsmith Open-Source Projects\n\n- **[Varlord](https://github.com/lzjever/varlord)** ⚙️ - Configuration management (this project)\n- **[Routilux](https://github.com/lzjever/routilux)** ⚡ - Event-driven workflow orchestration\n- **[Serilux](https://github.com/lzjever/serilux)** 📦 - Flexible serialization framework\n- **[Lexilux](https://github.com/lzjever/lexilux)** 🚀 - Unified LLM API client\n\n---\n\n## 🤝 Contributing\n\nWe welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.\n\n## 📄 License\n\nLicensed under the Apache License 2.0. See [LICENSE](LICENSE) for details.\n\n---\n\n## 🎯 TL;DR\n\n**Varlord solves configuration management once and for all:**\n\n1. ✅ **Define your config as a dataclass** - type-safe, validated\n2. ✅ **Add sources in priority order** - later overrides earlier\n3. ✅ **Call `load()`** - get a type-safe config object\n4. ✅ **Optional: Enable dynamic updates** - zero-downtime config changes\n\n**No more parsing. No more type conversion. No more priority confusion.**\n\n```python\n# Before: 50+ lines of parsing, type conversion, validation\n# After: 3 lines\ncfg = Config(model=AppConfig, sources=[sources.Env(), sources.CLI()])\napp = cfg.load()\n```\n\n**That's the Varlord promise. 🚀**\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Flzjever%2Fvarlord","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Flzjever%2Fvarlord","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Flzjever%2Fvarlord/lists"}