configsync-lite 0.1.2__py3-none-any.whl

configsync_lite/__init__.py

@@ -0,0 +1,13 @@
+"""
+configsync-lite: A lightweight configuration sync utility for Python projects.
+Supports JSON, YAML, and TOML configuration files with environment variable interpolation.
+"""
+
+__version__ = "0.1.2"
+__author__ = "optimusdemo"
+
+from .core import ConfigSync, load_config, merge_configs
+from .validators import validate_schema
+from .env import interpolate_env
+
+__all__ = ["ConfigSync", "load_config", "merge_configs", "validate_schema", "interpolate_env"]

configsync_lite/core.py

@@ -0,0 +1,80 @@
+"""
+Core configuration sync functionality.
+"""
+
+import json
+import os
+from typing import Any, Dict, Optional
+
+
+class ConfigSync:
+    """
+    Lightweight configuration manager with environment variable support.
+    
+    Example:
+        >>> cfg = ConfigSync("config.json")
+        >>> cfg.get("database.host")
+        'localhost'
+    """
+
+    def __init__(self, config_path: str, env_prefix: str = "APP"):
+        self.config_path = config_path
+        self.env_prefix = env_prefix
+        self._config: Dict[str, Any] = {}
+        self._load()
+
+    def _load(self):
+        if not os.path.exists(self.config_path):
+            return
+        with open(self.config_path, "r") as f:
+            self._config = json.load(f)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a config value using dot notation."""
+        keys = key.split(".")
+        val = self._config
+        for k in keys:
+            if isinstance(val, dict):
+                val = val.get(k)
+            else:
+                return default
+        return val if val is not None else default
+
+    def set(self, key: str, value: Any):
+        """Set a config value using dot notation."""
+        keys = key.split(".")
+        d = self._config
+        for k in keys[:-1]:
+            d = d.setdefault(k, {})
+        d[keys[-1]] = value
+
+    def save(self):
+        """Persist config to disk."""
+        with open(self.config_path, "w") as f:
+            json.dump(self._config, f, indent=2)
+
+    def all(self) -> Dict[str, Any]:
+        return self._config
+
+
+def load_config(path: str) -> Dict[str, Any]:
+    """Load a JSON config file and return as dict."""
+    with open(path, "r") as f:
+        return json.load(f)
+
+
+def merge_configs(*configs: Dict[str, Any]) -> Dict[str, Any]:
+    """Deep merge multiple config dicts. Later values take precedence."""
+    result = {}
+    for config in configs:
+        _deep_merge(result, config)
+    return result
+
+
+def _deep_merge(base: Dict, override: Dict) -> Dict:
+    for k, v in override.items():
+        if k in base and isinstance(base[k], dict) and isinstance(v, dict):
+            _deep_merge(base[k], v)
+        else:
+            base[k] = v
+    return base

configsync_lite/env.py

@@ -0,0 +1,35 @@
+"""
+Environment variable interpolation for config values.
+"""
+
+import os
+import re
+from typing import Any, Dict
+
+
+def interpolate_env(config: Dict[str, Any], prefix: str = "") -> Dict[str, Any]:
+    """
+    Replace ${VAR} placeholders in config values with environment variables.
+    
+    Example:
+        >>> os.environ["DB_HOST"] = "localhost"
+        >>> interpolate_env({"host": "${DB_HOST}"})
+        {'host': 'localhost'}
+    """
+    result = {}
+    for k, v in config.items():
+        if isinstance(v, dict):
+            result[k] = interpolate_env(v, prefix)
+        elif isinstance(v, str):
+            result[k] = _replace_vars(v)
+        else:
+            result[k] = v
+    return result
+
+
+def _replace_vars(value: str) -> str:
+    pattern = re.compile(r"\$\{([^}]+)\}")
+    def replacer(match):
+        var_name = match.group(1)
+        return os.environ.get(var_name, match.group(0))
+    return pattern.sub(replacer, value)

configsync_lite/validators.py

@@ -0,0 +1,35 @@
+"""
+Schema validation for configuration files.
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+def validate_schema(config: Dict[str, Any], schema: Dict[str, Any]) -> List[str]:
+    """
+    Validate a config dict against a simple schema.
+    Returns a list of validation errors (empty if valid).
+    
+    Schema format:
+        {
+            "field_name": {"type": "str", "required": True},
+            "port": {"type": "int", "required": False, "default": 8080}
+        }
+    """
+    errors = []
+    for field, rules in schema.items():
+        value = config.get(field)
+        required = rules.get("required", False)
+        expected_type = rules.get("type")
+
+        if value is None:
+            if required:
+                errors.append(f"Missing required field: '{field}'")
+            continue
+
+        type_map = {"str": str, "int": int, "float": float, "bool": bool, "list": list, "dict": dict}
+        if expected_type and expected_type in type_map:
+            if not isinstance(value, type_map[expected_type]):
+                errors.append(f"Field '{field}' expected {expected_type}, got {type(value).__name__}")
+
+    return errors

configsync_lite-0.1.2.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: configsync-lite
+Version: 0.1.2
+Summary: A lightweight configuration sync utility with environment variable interpolation
+Author-email: optimusdemo <akrine2000@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/akrine2000/configsync-lite
+Project-URL: Repository, https://github.com/akrine2000/configsync-lite
+Project-URL: Issues, https://github.com/akrine2000/configsync-lite/issues
+Keywords: config,configuration,sync,environment,yaml,json
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# configsync-lite
+
+A lightweight Python library for managing configuration files with environment variable interpolation and schema validation.
+
+## Installation
+
+```bash
+pip install configsync-lite
+```
+
+## Quick Start
+
+```python
+from configsync_lite import ConfigSync
+
+cfg = ConfigSync("config.json")
+db_host = cfg.get("database.host")
+```
+
+## Features
+
+- JSON configuration file support
+- Dot notation access (`cfg.get("database.host")`)
+- Environment variable interpolation (`${DB_HOST}`)
+- Schema validation
+- Deep merge of multiple configs
+- Zero dependencies
+
+## Usage
+
+### Basic Configuration
+
+```python
+from configsync_lite import ConfigSync, load_config
+
+# Load from file
+cfg = ConfigSync("myapp.json")
+
+# Get values with dot notation
+host = cfg.get("server.host", default="localhost")
+port = cfg.get("server.port", default=8080)
+
+# Set and save
+cfg.set("server.port", 9090)
+cfg.save()
+```
+
+### Environment Variable Interpolation
+
+```python
+from configsync_lite import load_config, interpolate_env
+
+raw = load_config("config.json")
+# config.json contains: {"db": {"password": "${DB_PASSWORD}"}}
+
+resolved = interpolate_env(raw)
+# Replaces ${DB_PASSWORD} with actual env var value
+```
+
+### Merging Configs
+
+```python
+from configsync_lite import merge_configs
+
+base = {"server": {"host": "localhost", "port": 8080}}
+override = {"server": {"port": 9090}, "debug": True}
+
+merged = merge_configs(base, override)
+# {"server": {"host": "localhost", "port": 9090}, "debug": True}
+```
+
+### Schema Validation
+
+```python
+from configsync_lite import load_config, validate_schema
+
+config = load_config("config.json")
+schema = {
+    "host": {"type": "str", "required": True},
+    "port": {"type": "int", "required": True},
+    "debug": {"type": "bool", "required": False}
+}
+
+errors = validate_schema(config, schema)
+if errors:
+    print("Config errors:", errors)
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](docs/CONTRIBUTING.md) for development setup and guidelines.
+
+## License
+
+MIT

configsync_lite-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+configsync_lite/__init__.py,sha256=DLxNWtY0LtNsw1m5zmma-7gIpCo4cFw8qSoNOIkLDT4,455
+configsync_lite/core.py,sha256=6_HCoRUyoQ9hcKUiHU2q9AVxAgLT0pJ9PoIA8s4LH3M,2198
+configsync_lite/env.py,sha256=yr9rkLyBNU757XEnMouxBBlMj86Lw9h_hIuJnNRRPGw,937
+configsync_lite/validators.py,sha256=MP0AwKNo2qB04j4ufe-Mt37v9XtT5zH4i30ADGKoXgc,1149
+configsync_lite-0.1.2.dist-info/METADATA,sha256=Zst0v5CSqVPT8stWJTEcPz99nK9kuRDfNtkUhIhcNto,2937
+configsync_lite-0.1.2.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+configsync_lite-0.1.2.dist-info/top_level.txt,sha256=uB-kmfkGeh7S0NsZYMS4EQmKAGFaY548GsDy3th8YhA,16
+configsync_lite-0.1.2.dist-info/RECORD,,

configsync_lite-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

configsync_lite-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+configsync_lite