configsync-lite 0.1.2__tar.gz

configsync_lite-0.1.2/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,95 @@
+# 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/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-0.1.2/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-0.1.2/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-0.1.2/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/configsync_lite.egg-info/PKG-INFO

@@ -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/configsync_lite.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+configsync_lite/__init__.py
+configsync_lite/core.py
+configsync_lite/env.py
+configsync_lite/validators.py
+configsync_lite.egg-info/PKG-INFO
+configsync_lite.egg-info/SOURCES.txt
+configsync_lite.egg-info/dependency_links.txt
+configsync_lite.egg-info/top_level.txt
+tests/test_core.py

configsync_lite-0.1.2/configsync_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

configsync_lite-0.1.2/configsync_lite.egg-info/top_level.txt

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

configsync_lite-0.1.2/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "configsync-lite"
+version = "0.1.2"
+description = "A lightweight configuration sync utility with environment variable interpolation"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "optimusdemo", email = "akrine2000@gmail.com"}
+]
+keywords = ["config", "configuration", "sync", "environment", "yaml", "json"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.9"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/akrine2000/configsync-lite"
+Repository = "https://github.com/akrine2000/configsync-lite"
+Issues = "https://github.com/akrine2000/configsync-lite/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["configsync_lite*"]

configsync_lite-0.1.2/setup.cfg

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

configsync_lite-0.1.2/tests/test_core.py

@@ -0,0 +1,82 @@
+"""Tests for configsync-lite core functionality."""
+
+import json
+import os
+import tempfile
+import pytest
+
+from configsync_lite import ConfigSync, load_config, merge_configs, validate_schema, interpolate_env
+
+
+@pytest.fixture
+def tmp_config(tmp_path):
+    config = {
+        "server": {"host": "localhost", "port": 8080},
+        "database": {"url": "${DB_URL}", "pool_size": 5},
+        "debug": False
+    }
+    path = tmp_path / "config.json"
+    path.write_text(json.dumps(config))
+    return str(path)
+
+
+def test_load_and_get(tmp_config):
+    cfg = ConfigSync(tmp_config)
+    assert cfg.get("server.host") == "localhost"
+    assert cfg.get("server.port") == 8080
+    assert cfg.get("debug") is False
+
+
+def test_get_default(tmp_config):
+    cfg = ConfigSync(tmp_config)
+    assert cfg.get("nonexistent.key", default="fallback") == "fallback"
+
+
+def test_set_and_save(tmp_config):
+    cfg = ConfigSync(tmp_config)
+    cfg.set("server.port", 9090)
+    cfg.save()
+    cfg2 = ConfigSync(tmp_config)
+    assert cfg2.get("server.port") == 9090
+
+
+def test_merge_configs():
+    base = {"server": {"host": "localhost", "port": 8080}, "debug": False}
+    override = {"server": {"port": 9090}, "debug": True}
+    merged = merge_configs(base, override)
+    assert merged["server"]["host"] == "localhost"
+    assert merged["server"]["port"] == 9090
+    assert merged["debug"] is True
+
+
+def test_interpolate_env(tmp_config):
+    os.environ["DB_URL"] = "postgresql://localhost/mydb"
+    raw = load_config(tmp_config)
+    resolved = interpolate_env(raw)
+    assert resolved["database"]["url"] == "postgresql://localhost/mydb"
+
+
+def test_validate_schema_valid(tmp_config):
+    config = {"host": "localhost", "port": 8080, "debug": True}
+    schema = {
+        "host": {"type": "str", "required": True},
+        "port": {"type": "int", "required": True},
+        "debug": {"type": "bool", "required": False}
+    }
+    errors = validate_schema(config, schema)
+    assert errors == []
+
+
+def test_validate_schema_missing_required():
+    config = {"port": 8080}
+    schema = {"host": {"type": "str", "required": True}}
+    errors = validate_schema(config, schema)
+    assert len(errors) == 1
+    assert "host" in errors[0]
+
+
+def test_validate_schema_wrong_type():
+    config = {"port": "not-an-int"}
+    schema = {"port": {"type": "int", "required": True}}
+    errors = validate_schema(config, schema)
+    assert len(errors) == 1