config2py 0.1.45__py3-none-any.whl → 0.1.46__py3-none-any.whl

config2py/__init__.py

@@ -24,3 +24,4 @@ from config2py.util import (
     process_path,
 )
 from config2py.sync_store import SyncStore, FileStore, JsonStore, register_extension
+from config2py import codecs  # noqa - Make codecs module available

config2py/codecs.py

@@ -0,0 +1,723 @@
+"""Extension-based codec registries for configuration file parsing.
+
+This module provides a flexible pattern for encoding and decoding configuration files
+based on their file extensions. It includes codecs for bytes <-> JSON-friendly Python types.
+
+Examples:
+    >>> # Basic usage
+    >>> data = {'name': 'config2py', 'version': '1.0'}
+    >>>
+    >>> # Encode to bytes
+    >>> encoded = encode_by_extension('config.json', data)
+    >>> assert isinstance(encoded, bytes)
+    >>>
+    >>> # Decode from bytes
+    >>> decoded = decode_by_extension('config.json', encoded)
+    >>> assert decoded == data
+    >>>
+    >>> # Register custom codec
+    >>> @register_decoder('.custom')
+    ... def decode_custom(data: bytes) -> dict:
+    ...     return {'custom': data.decode()}
+    >>>
+    >>> @register_encoder('.custom')
+    ... def encode_custom(obj: dict) -> bytes:
+    ...     return obj.get('custom', '').encode()
+
+The module automatically registers codecs for standard formats (json, toml, ini, etc.)
+and conditionally registers codecs that require third-party libraries (yaml, json5, etc.).
+"""
+
+from typing import Callable, TypeVar, Any, Optional
+import json
+import pickle
+import csv
+import io
+from configparser import ConfigParser
+from pathlib import Path
+
+__all__ = [
+    # Core functions
+    "decode_by_extension",
+    "encode_by_extension",
+    "get_extension",
+    # Registration functions
+    "register_codec",
+    "register_decoder",
+    "register_encoder",
+    # Registry access
+    "list_registered_extensions",
+    "is_extension_registered",
+    "get_codec_info",
+]
+
+VT = TypeVar("VT")
+EncodedT = TypeVar("EncodedT")
+
+# --------------------------------------------------------------------------------------
+# Core Registry
+# --------------------------------------------------------------------------------------
+
+EXTENSION_TO_DECODER: dict[str, Callable[[bytes], Any]] = {}
+EXTENSION_TO_ENCODER: dict[str, Callable[[Any], bytes]] = {}
+
+# Track which codecs require optional dependencies
+_CODEC_DEPENDENCIES: dict[str, str] = {}
+
+
+def get_extension(key: str) -> str:
+    """Extract extension from a key (filename, path, etc.).
+
+    Args:
+        key: A string that may contain a file extension
+
+    Returns:
+        Extension without the dot, or empty string if no extension found
+
+    Examples:
+        >>> get_extension('config.json')
+        'json'
+        >>> get_extension('/path/to/data.yaml')
+        'yaml'
+        >>> get_extension('no_extension')
+        ''
+        >>> get_extension('.env')
+        'env'
+        >>> get_extension('/path/to/.env')
+        'env'
+    """
+    if not key or "." not in key:
+        return ""
+
+    # Get the basename (last part of path)
+    basename = Path(key).name
+
+    # Handle dotfiles (e.g., .env, .gitignore)
+    if basename.startswith(".") and basename.count(".") == 1:
+        return basename.lstrip(".").lower()
+
+    # Normal case: extract extension using Path.suffix
+    suffix = Path(key).suffix
+    return suffix.lstrip(".").lower() if suffix else ""
+
+
+def decode_by_extension(key: str, data: bytes) -> Any:
+    """Decode data based on key's extension.
+
+    Args:
+        key: Key or filename with extension
+        data: Bytes to decode
+
+    Returns:
+        Decoded Python object
+
+    Raises:
+        ValueError: If no decoder registered for extension
+
+    Examples:
+        >>> data = b'{"key": "value"}'
+        >>> decode_by_extension('config.json', data)
+        {'key': 'value'}
+    """
+    ext = get_extension(key)
+    ext_with_dot = f".{ext}" if ext else ""
+    decoder = EXTENSION_TO_DECODER.get(ext_with_dot)
+    if decoder is None:
+        available = ", ".join(sorted(EXTENSION_TO_DECODER.keys()))
+        raise ValueError(
+            f"No decoder registered for extension: '{ext_with_dot}'. "
+            f"Available: {available}"
+        )
+    return decoder(data)
+
+
+def encode_by_extension(key: str, obj: Any) -> bytes:
+    """Encode object based on key's extension.
+
+    Args:
+        key: Key or filename with extension
+        obj: Python object to encode
+
+    Returns:
+        Encoded bytes
+
+    Raises:
+        ValueError: If no encoder registered for extension
+
+    Examples:
+        >>> obj = {'key': 'value'}
+        >>> encoded = encode_by_extension('config.json', obj)
+        >>> assert b'"key"' in encoded
+    """
+    ext = get_extension(key)
+    ext_with_dot = f".{ext}" if ext else ""
+    encoder = EXTENSION_TO_ENCODER.get(ext_with_dot)
+    if encoder is None:
+        available = ", ".join(sorted(EXTENSION_TO_ENCODER.keys()))
+        raise ValueError(
+            f"No encoder registered for extension: '{ext_with_dot}'. "
+            f"Available: {available}"
+        )
+    return encoder(obj)
+
+
+# --------------------------------------------------------------------------------------
+# Registration Functions
+# --------------------------------------------------------------------------------------
+
+
+def register_codec(
+    extension: str,
+    *,
+    encoder: Optional[Callable[[Any], bytes]] = None,
+    decoder: Optional[Callable[[bytes], Any]] = None,
+    overwrite: bool = False,
+    dependency: Optional[str] = None,
+):
+    """Register encoder and/or decoder for an extension.
+
+    Args:
+        extension: File extension (with or without leading dot)
+        encoder: Function to encode objects to bytes
+        decoder: Function to decode bytes to objects
+        overwrite: Whether to overwrite existing codec
+        dependency: Optional package name required for this codec
+
+    Raises:
+        ValueError: If codec already registered and overwrite=False
+
+    Examples:
+        >>> def my_encoder(obj): return str(obj).encode()
+        >>> def my_decoder(data): return eval(data.decode())
+        >>> register_codec('.custom', encoder=my_encoder, decoder=my_decoder, overwrite=True)
+    """
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    extension = extension.lower()
+
+    if not overwrite:
+        if encoder and extension in EXTENSION_TO_ENCODER:
+            raise ValueError(f"Encoder for '{extension}' already registered")
+        if decoder and extension in EXTENSION_TO_DECODER:
+            raise ValueError(f"Decoder for '{extension}' already registered")
+
+    if encoder:
+        EXTENSION_TO_ENCODER[extension] = encoder
+    if decoder:
+        EXTENSION_TO_DECODER[extension] = decoder
+    if dependency:
+        _CODEC_DEPENDENCIES[extension] = dependency
+
+
+def register_decoder(extension: str, *, overwrite: bool = False):
+    """Decorator to register a decoder function.
+
+    Args:
+        extension: File extension (with or without leading dot)
+        overwrite: Whether to overwrite existing decoder
+
+    Returns:
+        Decorator function
+
+    Examples:
+        >>> @register_decoder('.custom', overwrite=True)
+        ... def decode_custom(data: bytes) -> dict:
+        ...     return {'data': data.decode()}
+    """
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    extension = extension.lower()
+
+    def decorator(func: Callable[[bytes], Any]) -> Callable:
+        if not overwrite and extension in EXTENSION_TO_DECODER:
+            raise ValueError(f"Decoder for '{extension}' already registered")
+        EXTENSION_TO_DECODER[extension] = func
+        return func
+
+    return decorator
+
+
+def register_encoder(extension: str, *, overwrite: bool = False):
+    """Decorator to register an encoder function.
+
+    Args:
+        extension: File extension (with or without leading dot)
+        overwrite: Whether to overwrite existing encoder
+
+    Returns:
+        Decorator function
+
+    Examples:
+        >>> @register_encoder('.custom', overwrite=True)
+        ... def encode_custom(obj: dict) -> bytes:
+        ...     return obj.get('data', '').encode()
+    """
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    extension = extension.lower()
+
+    def decorator(func: Callable[[Any], bytes]) -> Callable:
+        if not overwrite and extension in EXTENSION_TO_ENCODER:
+            raise ValueError(f"Encoder for '{extension}' already registered")
+        EXTENSION_TO_ENCODER[extension] = func
+        return func
+
+    return decorator
+
+
+# --------------------------------------------------------------------------------------
+# Registry Introspection
+# --------------------------------------------------------------------------------------
+
+
+def list_registered_extensions() -> list[str]:
+    """List all registered extensions.
+
+    Returns:
+        Sorted list of registered extensions
+
+    Examples:
+        >>> extensions = list_registered_extensions()
+        >>> '.json' in extensions
+        True
+    """
+    all_extensions = set(EXTENSION_TO_DECODER.keys()) | set(EXTENSION_TO_ENCODER.keys())
+    return sorted(all_extensions)
+
+
+def is_extension_registered(extension: str) -> bool:
+    """Check if an extension has any codec registered.
+
+    Args:
+        extension: File extension (with or without leading dot)
+
+    Returns:
+        True if decoder or encoder is registered
+
+    Examples:
+        >>> is_extension_registered('.json')
+        True
+        >>> is_extension_registered('.nonexistent')
+        False
+    """
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    extension = extension.lower()
+    return extension in EXTENSION_TO_DECODER or extension in EXTENSION_TO_ENCODER
+
+
+def get_codec_info(extension: str) -> dict[str, Any]:
+    """Get information about a registered codec.
+
+    Args:
+        extension: File extension (with or without leading dot)
+
+    Returns:
+        Dictionary with codec information
+
+    Examples:
+        >>> info = get_codec_info('.json')
+        >>> info['has_encoder']
+        True
+        >>> info['has_decoder']
+        True
+    """
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    extension = extension.lower()
+
+    return {
+        "extension": extension,
+        "has_encoder": extension in EXTENSION_TO_ENCODER,
+        "has_decoder": extension in EXTENSION_TO_DECODER,
+        "dependency": _CODEC_DEPENDENCIES.get(extension),
+    }
+
+
+# --------------------------------------------------------------------------------------
+# Standard Library Codecs (Always Available)
+# --------------------------------------------------------------------------------------
+
+# JSON - Most common config format
+register_codec(
+    ".json",
+    encoder=lambda obj: json.dumps(obj, indent=2, ensure_ascii=False).encode("utf-8"),
+    decoder=lambda data: json.loads(data.decode("utf-8")),
+)
+
+# Pickle - Python object serialization (not text-based, but useful)
+register_codec(
+    ".pkl",
+    encoder=pickle.dumps,
+    decoder=pickle.loads,
+)
+register_codec(".pickle", encoder=pickle.dumps, decoder=pickle.loads)
+
+# Plain text
+register_codec(
+    ".txt",
+    encoder=lambda obj: str(obj).encode("utf-8"),
+    decoder=lambda data: data.decode("utf-8"),
+)
+
+
+# Line-separated values (LSV) - one value per line
+def _lsv_encoder(obj: Any) -> bytes:
+    """Encode list/iterable to line-separated values."""
+    if isinstance(obj, (list, tuple)):
+        return "\n".join(str(item) for item in obj).encode("utf-8")
+    elif isinstance(obj, str):
+        return obj.encode("utf-8")
+    else:
+        return str(obj).encode("utf-8")
+
+
+def _lsv_decoder(data: bytes) -> list[str]:
+    """Decode line-separated values to list."""
+    text = data.decode("utf-8")
+    return [line.strip() for line in text.splitlines() if line.strip()]
+
+
+register_codec(".lsv", encoder=_lsv_encoder, decoder=_lsv_decoder)
+register_codec(".list", encoder=_lsv_encoder, decoder=_lsv_decoder)
+register_codec(".lines", encoder=_lsv_encoder, decoder=_lsv_decoder)
+
+
+# CSV - Comma-separated values
+def _csv_encoder(obj: Any) -> bytes:
+    """Encode list of dicts or list of lists to CSV."""
+    output = io.StringIO()
+
+    if not obj:
+        return b""
+
+    if isinstance(obj, dict):
+        # Single dict - treat as one row
+        obj = [obj]
+
+    if isinstance(obj[0], dict):
+        # List of dicts
+        fieldnames = list(obj[0].keys())
+        writer = csv.DictWriter(output, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(obj)
+    else:
+        # List of lists/tuples
+        writer = csv.writer(output)
+        writer.writerows(obj)
+
+    return output.getvalue().encode("utf-8")
+
+
+def _csv_decoder(data: bytes) -> list[dict[str, str]]:
+    """Decode CSV to list of dicts."""
+    text = data.decode("utf-8")
+    reader = csv.DictReader(io.StringIO(text))
+    return list(reader)
+
+
+register_codec(".csv", encoder=_csv_encoder, decoder=_csv_decoder)
+
+
+# TSV - Tab-separated values
+def _tsv_encoder(obj: Any) -> bytes:
+    """Encode list of dicts or list of lists to TSV."""
+    output = io.StringIO()
+
+    if not obj:
+        return b""
+
+    if isinstance(obj, dict):
+        obj = [obj]
+
+    if isinstance(obj[0], dict):
+        fieldnames = list(obj[0].keys())
+        writer = csv.DictWriter(output, fieldnames=fieldnames, delimiter="\t")
+        writer.writeheader()
+        writer.writerows(obj)
+    else:
+        writer = csv.writer(output, delimiter="\t")
+        writer.writerows(obj)
+
+    return output.getvalue().encode("utf-8")
+
+
+def _tsv_decoder(data: bytes) -> list[dict[str, str]]:
+    """Decode TSV to list of dicts."""
+    text = data.decode("utf-8")
+    reader = csv.DictReader(io.StringIO(text), delimiter="\t")
+    return list(reader)
+
+
+register_codec(".tsv", encoder=_tsv_encoder, decoder=_tsv_decoder)
+register_codec(".tab", encoder=_tsv_encoder, decoder=_tsv_decoder)
+
+
+# INI/CFG - ConfigParser format
+def _ini_encoder(obj: dict) -> bytes:
+    """Encode dict to INI format."""
+    config = ConfigParser()
+    for section, values in obj.items():
+        config[section] = {k: str(v) for k, v in values.items()}
+    output = io.StringIO()
+    config.write(output)
+    return output.getvalue().encode("utf-8")
+
+
+def _ini_decoder(data: bytes) -> dict[str, dict[str, str]]:
+    """Decode INI format to nested dict."""
+    config = ConfigParser()
+    config.read_string(data.decode("utf-8"))
+    return {section: dict(config[section]) for section in config.sections()}
+
+
+register_codec(".ini", encoder=_ini_encoder, decoder=_ini_decoder)
+register_codec(".cfg", encoder=_ini_encoder, decoder=_ini_decoder)
+register_codec(".conf", encoder=_ini_encoder, decoder=_ini_decoder)
+
+# XML - Basic XML support using ElementTree
+try:
+    import xml.etree.ElementTree as ET
+
+    def _xml_encoder(obj: dict) -> bytes:
+        """Encode dict to simple XML format."""
+
+        def dict_to_xml(tag: str, d: dict) -> ET.Element:
+            """Convert dict to XML element."""
+            elem = ET.Element(tag)
+            for key, val in d.items():
+                child = ET.SubElement(elem, key)
+                if isinstance(val, dict):
+                    for k, v in val.items():
+                        subchild = ET.SubElement(child, k)
+                        subchild.text = str(v)
+                elif isinstance(val, (list, tuple)):
+                    for item in val:
+                        item_elem = ET.SubElement(child, "item")
+                        item_elem.text = str(item)
+                else:
+                    child.text = str(val)
+            return elem
+
+        root = dict_to_xml("root", obj)
+        return ET.tostring(root, encoding="utf-8", xml_declaration=True)
+
+    def _xml_decoder(data: bytes) -> dict:
+        """Decode XML to dict."""
+
+        def xml_to_dict(elem: ET.Element) -> dict:
+            """Convert XML element to dict."""
+            result = {}
+            for child in elem:
+                if len(child) == 0:
+                    # Leaf node
+                    result[child.tag] = child.text
+                else:
+                    # Has children
+                    if child.tag not in result:
+                        result[child.tag] = {}
+                    child_dict = xml_to_dict(child)
+                    if isinstance(result[child.tag], dict):
+                        result[child.tag].update(child_dict)
+                    else:
+                        result[child.tag] = child_dict
+            return result
+
+        root = ET.fromstring(data)
+        return xml_to_dict(root)
+
+    register_codec(".xml", encoder=_xml_encoder, decoder=_xml_decoder)
+except ImportError:
+    pass
+
+# --------------------------------------------------------------------------------------
+# TOML - Conditionally available based on Python version
+# --------------------------------------------------------------------------------------
+
+# Try Python 3.11+ built-in tomllib for reading
+try:
+    import tomllib
+
+    register_codec(
+        ".toml",
+        decoder=lambda data: tomllib.loads(data.decode("utf-8")),
+    )
+except ImportError:
+    # Try tomli for older Python versions
+    try:
+        import tomli
+
+        register_codec(
+            ".toml",
+            decoder=lambda data: tomli.loads(data.decode("utf-8")),
+            dependency="tomli",
+        )
+    except ImportError:
+        pass
+
+# Try tomli_w for TOML writing (not in stdlib)
+try:
+    import tomli_w
+
+    # Register encoder (or update if decoder already registered)
+    if ".toml" in EXTENSION_TO_DECODER:
+        EXTENSION_TO_ENCODER[".toml"] = lambda obj: tomli_w.dumps(obj).encode("utf-8")
+    else:
+        register_codec(
+            ".toml",
+            encoder=lambda obj: tomli_w.dumps(obj).encode("utf-8"),
+            dependency="tomli_w",
+        )
+except ImportError:
+    pass
+
+# --------------------------------------------------------------------------------------
+# Third-Party Codecs (Conditionally Registered)
+# --------------------------------------------------------------------------------------
+
+# YAML - Requires PyYAML
+try:
+    import yaml
+
+    def _yaml_encoder(obj: Any) -> bytes:
+        """Encode object to YAML."""
+        return yaml.dump(obj, default_flow_style=False, allow_unicode=True).encode(
+            "utf-8"
+        )
+
+    def _yaml_decoder(data: bytes) -> Any:
+        """Decode YAML to Python object."""
+        return yaml.safe_load(data.decode("utf-8"))
+
+    register_codec(
+        ".yaml", encoder=_yaml_encoder, decoder=_yaml_decoder, dependency="pyyaml"
+    )
+    register_codec(
+        ".yml", encoder=_yaml_encoder, decoder=_yaml_decoder, dependency="pyyaml"
+    )
+except ImportError:
+    pass
+
+# ENV - Environment files (requires python-dotenv for full support)
+try:
+    from dotenv import dotenv_values
+
+    def _env_encoder(obj: dict) -> bytes:
+        """Encode dict to .env format."""
+        lines = []
+        for key, value in obj.items():
+            # Quote values with spaces or special chars
+            if isinstance(value, str) and (
+                " " in value or '"' in value or "'" in value
+            ):
+                value = f'"{value}"'
+            lines.append(f"{key}={value}")
+        return "\n".join(lines).encode("utf-8")
+
+    def _env_decoder(data: bytes) -> dict:
+        """Decode .env file to dict."""
+        # Write to temp StringIO for dotenv_values
+        return dotenv_values(stream=io.StringIO(data.decode("utf-8")))
+
+    register_codec(
+        ".env", encoder=_env_encoder, decoder=_env_decoder, dependency="python-dotenv"
+    )
+except ImportError:
+    # Fallback simple .env parser without dotenv
+    def _env_encoder_simple(obj: dict) -> bytes:
+        """Simple .env encoder without python-dotenv."""
+        lines = []
+        for key, value in obj.items():
+            if isinstance(value, str) and (
+                " " in value or '"' in value or "'" in value
+            ):
+                value = f'"{value}"'
+            lines.append(f"{key}={value}")
+        return "\n".join(lines).encode("utf-8")
+
+    def _env_decoder_simple(data: bytes) -> dict:
+        """Simple .env decoder without python-dotenv."""
+        result = {}
+        for line in data.decode("utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#"):
+                if "=" in line:
+                    key, _, value = line.partition("=")
+                    key = key.strip()
+                    value = value.strip().strip('"').strip("'")
+                    result[key] = value
+        return result
+
+    register_codec(".env", encoder=_env_encoder_simple, decoder=_env_decoder_simple)
+
+# JSON5 - More lenient JSON (requires json5 package)
+try:
+    import json5
+
+    register_codec(
+        ".json5",
+        encoder=lambda obj: json5.dumps(obj, indent=2).encode("utf-8"),
+        decoder=lambda data: json5.loads(data.decode("utf-8")),
+        dependency="json5",
+    )
+except ImportError:
+    pass
+
+# Properties files (Java-style)
+try:
+    from jproperties import Properties
+
+    def _properties_encoder(obj: dict) -> bytes:
+        """Encode dict to .properties format."""
+        props = Properties()
+        for key, value in obj.items():
+            props[key] = str(value)
+        output = io.BytesIO()
+        props.store(output, encoding="utf-8")
+        return output.getvalue()
+
+    def _properties_decoder(data: bytes) -> dict:
+        """Decode .properties file to dict."""
+        props = Properties()
+        props.load(io.BytesIO(data), encoding="utf-8")
+        return {k: v.data for k, v in props.items()}
+
+    register_codec(
+        ".properties",
+        encoder=_properties_encoder,
+        decoder=_properties_decoder,
+        dependency="jproperties",
+    )
+except ImportError:
+    # Fallback simple properties parser
+    def _properties_encoder_simple(obj: dict) -> bytes:
+        """Simple .properties encoder."""
+        lines = []
+        for key, value in obj.items():
+            # Escape special characters
+            value_str = str(value).replace("\\", "\\\\").replace("\n", "\\n")
+            lines.append(f"{key}={value_str}")
+        return "\n".join(lines).encode("utf-8")
+
+    def _properties_decoder_simple(data: bytes) -> dict:
+        """Simple .properties decoder."""
+        result = {}
+        for line in data.decode("utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and not line.startswith("!"):
+                if "=" in line or ":" in line:
+                    # Support both = and : as separators
+                    sep = "=" if "=" in line else ":"
+                    key, _, value = line.partition(sep)
+                    key = key.strip()
+                    value = value.strip()
+                    # Unescape
+                    value = value.replace("\\n", "\n").replace("\\\\", "\\")
+                    result[key] = value
+        return result
+
+    register_codec(
+        ".properties",
+        encoder=_properties_encoder_simple,
+        decoder=_properties_decoder_simple,
+    )

config2py/tests/test_codecs.py

@@ -0,0 +1,378 @@
+"""Tests for config2py.codecs module."""
+
+import pytest
+from config2py import codecs
+
+
+class TestCodecRegistry:
+    """Test codec registration and introspection."""
+
+    def test_list_registered_extensions(self):
+        """Test listing all registered extensions."""
+        extensions = codecs.list_registered_extensions()
+        assert isinstance(extensions, list)
+        assert '.json' in extensions
+        assert '.ini' in extensions
+        assert '.csv' in extensions
+
+    def test_is_extension_registered(self):
+        """Test checking if extension is registered."""
+        assert codecs.is_extension_registered('.json')
+        assert codecs.is_extension_registered('json')  # without dot
+        assert not codecs.is_extension_registered('.nonexistent')
+
+    def test_get_codec_info(self):
+        """Test getting codec information."""
+        info = codecs.get_codec_info('.json')
+        assert info['extension'] == '.json'
+        assert info['has_encoder'] is True
+        assert info['has_decoder'] is True
+        assert info['dependency'] is None  # json is stdlib
+
+    def test_get_extension(self):
+        """Test extension extraction."""
+        assert codecs.get_extension('config.json') == 'json'
+        assert codecs.get_extension('/path/to/file.yaml') == 'yaml'
+        assert codecs.get_extension('no_extension') == ''
+        assert codecs.get_extension('file.tar.gz') == 'gz'
+
+
+class TestJSONCodec:
+    """Test JSON encoding/decoding."""
+
+    def test_json_roundtrip(self):
+        """Test JSON encode -> decode roundtrip."""
+        data = {'name': 'test', 'value': 42, 'nested': {'key': 'value'}}
+        encoded = codecs.encode_by_extension('config.json', data)
+        assert isinstance(encoded, bytes)
+        decoded = codecs.decode_by_extension('config.json', encoded)
+        assert decoded == data
+
+    def test_json_with_unicode(self):
+        """Test JSON with unicode characters."""
+        data = {'message': 'Hello 世界', 'emoji': '🎉'}
+        encoded = codecs.encode_by_extension('data.json', data)
+        decoded = codecs.decode_by_extension('data.json', encoded)
+        assert decoded == data
+
+
+class TestPickleCodec:
+    """Test pickle encoding/decoding."""
+
+    def test_pickle_roundtrip(self):
+        """Test pickle encode -> decode roundtrip."""
+        data = {'list': [1, 2, 3], 'tuple': (4, 5, 6), 'set': {7, 8, 9}}
+        encoded = codecs.encode_by_extension('data.pkl', data)
+        decoded = codecs.decode_by_extension('data.pkl', encoded)
+        assert decoded == data
+
+    def test_pickle_alias(self):
+        """Test .pickle extension alias."""
+        data = {'key': 'value'}
+        encoded = codecs.encode_by_extension('data.pickle', data)
+        decoded = codecs.decode_by_extension('data.pickle', encoded)
+        assert decoded == data
+
+
+class TestTextCodec:
+    """Test plain text encoding/decoding."""
+
+    def test_text_roundtrip(self):
+        """Test text encode -> decode roundtrip."""
+        text = "Hello, World!\nThis is a test."
+        encoded = codecs.encode_by_extension('file.txt', text)
+        decoded = codecs.decode_by_extension('file.txt', encoded)
+        assert decoded == text
+
+
+class TestLSVCodec:
+    """Test line-separated values encoding/decoding."""
+
+    def test_lsv_list_roundtrip(self):
+        """Test LSV with list input."""
+        data = ['apple', 'banana', 'cherry']
+        encoded = codecs.encode_by_extension('data.lsv', data)
+        decoded = codecs.decode_by_extension('data.lsv', encoded)
+        assert decoded == data
+
+    def test_lsv_aliases(self):
+        """Test .list and .lines aliases."""
+        data = ['one', 'two', 'three']
+
+        # .list extension
+        encoded = codecs.encode_by_extension('data.list', data)
+        decoded = codecs.decode_by_extension('data.list', encoded)
+        assert decoded == data
+
+        # .lines extension
+        encoded = codecs.encode_by_extension('data.lines', data)
+        decoded = codecs.decode_by_extension('data.lines', encoded)
+        assert decoded == data
+
+
+class TestCSVCodec:
+    """Test CSV encoding/decoding."""
+
+    def test_csv_dict_list_roundtrip(self):
+        """Test CSV with list of dicts."""
+        data = [
+            {'name': 'Alice', 'age': '30'},
+            {'name': 'Bob', 'age': '25'},
+        ]
+        encoded = codecs.encode_by_extension('data.csv', data)
+        decoded = codecs.decode_by_extension('data.csv', encoded)
+        # CSV decoder returns all values as strings
+        assert decoded == data
+
+    def test_csv_empty(self):
+        """Test CSV with empty data."""
+        encoded = codecs.encode_by_extension('data.csv', [])
+        assert encoded == b''
+
+
+class TestTSVCodec:
+    """Test TSV encoding/decoding."""
+
+    def test_tsv_roundtrip(self):
+        """Test TSV encode -> decode roundtrip."""
+        data = [
+            {'col1': 'value1', 'col2': 'value2'},
+            {'col1': 'value3', 'col2': 'value4'},
+        ]
+        encoded = codecs.encode_by_extension('data.tsv', data)
+        decoded = codecs.decode_by_extension('data.tsv', encoded)
+        assert decoded == data
+
+    def test_tsv_tab_alias(self):
+        """Test .tab extension alias."""
+        data = [{'a': '1', 'b': '2'}]
+        encoded = codecs.encode_by_extension('data.tab', data)
+        decoded = codecs.decode_by_extension('data.tab', encoded)
+        assert decoded == data
+
+
+class TestINICodec:
+    """Test INI/CFG encoding/decoding."""
+
+    def test_ini_roundtrip(self):
+        """Test INI encode -> decode roundtrip."""
+        data = {
+            'section1': {'key1': 'value1', 'key2': 'value2'},
+            'section2': {'key3': 'value3'},
+        }
+        encoded = codecs.encode_by_extension('config.ini', data)
+        decoded = codecs.decode_by_extension('config.ini', encoded)
+        assert decoded == data
+
+    def test_cfg_alias(self):
+        """Test .cfg extension."""
+        data = {'database': {'host': 'localhost', 'port': '5432'}}
+        encoded = codecs.encode_by_extension('config.cfg', data)
+        decoded = codecs.decode_by_extension('config.cfg', encoded)
+        assert decoded == data
+
+    def test_conf_alias(self):
+        """Test .conf extension."""
+        data = {'settings': {'debug': 'true'}}
+        encoded = codecs.encode_by_extension('app.conf', data)
+        decoded = codecs.decode_by_extension('app.conf', encoded)
+        assert decoded == data
+
+
+class TestXMLCodec:
+    """Test XML encoding/decoding (if available)."""
+
+    def test_xml_roundtrip(self):
+        """Test XML encode -> decode roundtrip."""
+        if not codecs.is_extension_registered('.xml'):
+            pytest.skip("XML codec not available")
+
+        data = {'config': {'setting1': 'value1', 'setting2': 'value2'}}
+        encoded = codecs.encode_by_extension('config.xml', data)
+        decoded = codecs.decode_by_extension('config.xml', encoded)
+        # Basic structure should match
+        assert 'config' in decoded
+
+
+class TestENVCodec:
+    """Test .env file encoding/decoding."""
+
+    def test_env_roundtrip(self):
+        """Test .env encode -> decode roundtrip."""
+        data = {
+            'DATABASE_URL': 'postgresql://localhost/db',
+            'API_KEY': 'secret123',
+            'DEBUG': 'true',
+        }
+        encoded = codecs.encode_by_extension('.env', data)
+        decoded = codecs.decode_by_extension('.env', encoded)
+        assert decoded == data
+
+    def test_env_with_spaces(self):
+        """Test .env with values containing spaces."""
+        data = {'MESSAGE': 'Hello World', 'PATH': '/usr/bin:/usr/local/bin'}
+        encoded = codecs.encode_by_extension('.env', data)
+        decoded = codecs.decode_by_extension('.env', encoded)
+        # Values should be preserved (quotes may be added/removed)
+        assert 'MESSAGE' in decoded
+        assert 'PATH' in decoded
+
+
+class TestPropertiesCodec:
+    """Test .properties file encoding/decoding."""
+
+    def test_properties_roundtrip(self):
+        """Test .properties encode -> decode roundtrip."""
+        data = {
+            'app.name': 'MyApp',
+            'app.version': '1.0.0',
+            'server.port': '8080',
+        }
+        encoded = codecs.encode_by_extension('config.properties', data)
+        decoded = codecs.decode_by_extension('config.properties', encoded)
+        assert decoded == data
+
+
+class TestCustomCodecRegistration:
+    """Test custom codec registration."""
+
+    def test_register_codec_function(self):
+        """Test registering codec via function."""
+
+        def custom_encoder(obj):
+            return f"CUSTOM:{obj}".encode()
+
+        def custom_decoder(data):
+            return data.decode().replace('CUSTOM:', '')
+
+        codecs.register_codec(
+            '.custom',
+            encoder=custom_encoder,
+            decoder=custom_decoder,
+            overwrite=True,
+        )
+
+        data = "test data"
+        encoded = codecs.encode_by_extension('file.custom', data)
+        decoded = codecs.decode_by_extension('file.custom', encoded)
+        assert decoded == data
+
+        # Cleanup
+        del codecs.EXTENSION_TO_ENCODER['.custom']
+        del codecs.EXTENSION_TO_DECODER['.custom']
+
+    def test_register_codec_decorator(self):
+        """Test registering codec via decorators."""
+
+        @codecs.register_encoder('.test')
+        def encode_test(obj):
+            return f"TEST:{obj}".encode()
+
+        @codecs.register_decoder('.test')
+        def decode_test(data):
+            return data.decode().replace('TEST:', '')
+
+        data = "hello"
+        encoded = codecs.encode_by_extension('data.test', data)
+        decoded = codecs.decode_by_extension('data.test', encoded)
+        assert decoded == data
+
+        # Cleanup
+        del codecs.EXTENSION_TO_ENCODER['.test']
+        del codecs.EXTENSION_TO_DECODER['.test']
+
+    def test_register_duplicate_raises_error(self):
+        """Test that registering duplicate codec raises error."""
+        # JSON is already registered
+        with pytest.raises(ValueError, match="already registered"):
+            codecs.register_codec('.json', encoder=lambda x: b'')
+
+    def test_register_with_overwrite(self):
+        """Test that overwrite=True allows replacing codec."""
+
+        def new_encoder(obj):
+            return b'NEW'
+
+        # This should not raise
+        codecs.register_codec(
+            '.json',
+            encoder=new_encoder,
+            overwrite=True,
+        )
+
+        # Restore original
+        codecs.register_codec(
+            '.json',
+            encoder=lambda obj: codecs.json.dumps(
+                obj, indent=2, ensure_ascii=False
+            ).encode('utf-8'),
+            overwrite=True,
+        )
+
+
+class TestErrorHandling:
+    """Test error handling."""
+
+    def test_unknown_extension_encoder(self):
+        """Test encoding with unknown extension raises error."""
+        with pytest.raises(ValueError, match="No encoder registered"):
+            codecs.encode_by_extension('file.unknown', {})
+
+    def test_unknown_extension_decoder(self):
+        """Test decoding with unknown extension raises error."""
+        with pytest.raises(ValueError, match="No decoder registered"):
+            codecs.decode_by_extension('file.unknown', b'')
+
+
+class TestConditionalCodecs:
+    """Test conditionally available codecs."""
+
+    def test_toml_if_available(self):
+        """Test TOML codec if available."""
+        if not codecs.is_extension_registered('.toml'):
+            pytest.skip("TOML codec not available")
+
+        data = {'table': {'key': 'value', 'number': 42}}
+
+        has_encoder = '.toml' in codecs.EXTENSION_TO_ENCODER
+        has_decoder = '.toml' in codecs.EXTENSION_TO_DECODER
+
+        if has_encoder and has_decoder:
+            encoded = codecs.encode_by_extension('config.toml', data)
+            decoded = codecs.decode_by_extension('config.toml', encoded)
+            assert decoded == data
+        elif has_decoder:
+            # tomllib (3.11+) or tomli available for reading, but no tomli_w for writing
+            toml_bytes = b'[table]\nkey = "value"\nnumber = 42\n'
+            decoded = codecs.decode_by_extension('config.toml', toml_bytes)
+            assert decoded == data
+
+    def test_yaml_if_available(self):
+        """Test YAML codec if available."""
+        if not codecs.is_extension_registered('.yaml'):
+            pytest.skip("YAML codec not available")
+
+        data = {'key': 'value', 'list': [1, 2, 3], 'nested': {'a': 'b'}}
+        encoded = codecs.encode_by_extension('config.yaml', data)
+        decoded = codecs.decode_by_extension('config.yaml', encoded)
+        assert decoded == data
+
+    def test_yml_alias_if_available(self):
+        """Test .yml alias if YAML available."""
+        if not codecs.is_extension_registered('.yml'):
+            pytest.skip("YAML codec not available")
+
+        data = {'test': 'data'}
+        encoded = codecs.encode_by_extension('config.yml', data)
+        decoded = codecs.decode_by_extension('config.yml', encoded)
+        assert decoded == data
+
+    def test_json5_if_available(self):
+        """Test JSON5 codec if available."""
+        if not codecs.is_extension_registered('.json5'):
+            pytest.skip("JSON5 codec not available")
+
+        data = {'key': 'value', 'number': 123}
+        encoded = codecs.encode_by_extension('config.json5', data)
+        decoded = codecs.decode_by_extension('config.json5', encoded)
+        assert decoded == data

config2py/util.py

@@ -470,7 +470,7 @@ def get_app_folder(
     app_data_folder_does_not_exist = not os.path.isdir(app_data_path)
 
     if app_data_folder_does_not_exist and ensure_exists:
-        setup_callback(app_data_path, ensure_exists=ensure_exists)
+        setup_callback(app_data_path)
     return app_data_path
 
 

{config2py-0.1.45.dist-info → config2py-0.1.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: config2py
-Version: 0.1.45
+Version: 0.1.46
 Summary: Simplified reading and writing configurations from various sources and formats
 Project-URL: Homepage, https://github.com/i2mint/config2py
 License: Apache-2.0
@@ -9,6 +9,20 @@ Requires-Python: >=3.10
 Requires-Dist: dol
 Requires-Dist: i2
 Requires-Dist: importlib-resources; python_version < '3.9'
+Provides-Extra: all
+Requires-Dist: jproperties>=2.1.0; extra == 'all'
+Requires-Dist: json5>=0.9.0; extra == 'all'
+Requires-Dist: python-dotenv>=1.0.0; extra == 'all'
+Requires-Dist: pyyaml>=6.0; extra == 'all'
+Requires-Dist: tomli-w>=1.0.0; extra == 'all'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'all'
+Provides-Extra: all-codecs
+Requires-Dist: jproperties>=2.1.0; extra == 'all-codecs'
+Requires-Dist: json5>=0.9.0; extra == 'all-codecs'
+Requires-Dist: python-dotenv>=1.0.0; extra == 'all-codecs'
+Requires-Dist: pyyaml>=6.0; extra == 'all-codecs'
+Requires-Dist: tomli-w>=1.0.0; extra == 'all-codecs'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'all-codecs'
 Provides-Extra: dev
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
@@ -16,6 +30,17 @@ Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: sphinx-rtd-theme>=1.0; extra == 'docs'
 Requires-Dist: sphinx>=6.0; extra == 'docs'
+Provides-Extra: env
+Requires-Dist: python-dotenv>=1.0.0; extra == 'env'
+Provides-Extra: json5
+Requires-Dist: json5>=0.9.0; extra == 'json5'
+Provides-Extra: properties
+Requires-Dist: jproperties>=2.1.0; extra == 'properties'
+Provides-Extra: toml
+Requires-Dist: tomli-w>=1.0.0; extra == 'toml'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'toml'
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0; extra == 'yaml'
 Description-Content-Type: text/markdown
 
 # config2py

{config2py-0.1.45.dist-info → config2py-0.1.46.dist-info}/RECORD

@@ -1,16 +1,18 @@
-config2py/__init__.py,sha256=-IWX8fBXWhpcvJk0TRDemdo_l_jrVQ-g860VC4bgifE,976
+config2py/__init__.py,sha256=XR2UBVjQaraafNr9qynIH41O7OeFtQYD07zZo5Og2i0,1044
 config2py/base.py,sha256=8qVfdQzfX7OABFUU_drtgQXC6gsAegRctYVyZHjidkY,15883
+config2py/codecs.py,sha256=LFO_rDYwgJ6S1dfZQcNk4mDu5CHXkc01p-cxW69TVQo,22655
 config2py/errors.py,sha256=QdwGsoJhv6LHDHp-_yyz4oUg1Fgu4S-S7O2nuA0a5cw,203
 config2py/s_configparser.py,sha256=yI3u_CbhfClHQ47_JLKPOvOXkAYYFKxLzv8Q9NuO030,15851
 config2py/sync_store.py,sha256=V1Vkhw1ofGF_MppGlpL1B8BUWHIhPapos7-dzsPB3N8,13954
 config2py/tools.py,sha256=kGy7iktvWyUof5yPt2qA7DMowipRhSKXam4Mh4TN2Ck,9207
-config2py/util.py,sha256=8Vfb40-O994r0j5AtYXcgiRtm4sKOc1ezsCKmC6lj88,23317
+config2py/util.py,sha256=2R9pCwi2_5nPcslq_OFyonhZLbWIMCUBuBeA3ZbGhZU,23288
 config2py/scrap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 config2py/tests/__init__.py,sha256=VI7rHivkD2Vh3z9tmEdDsq-KKLV2_YkJyj9IeW-FyLE,330
+config2py/tests/test_codecs.py,sha256=uvz_DL881FRh5Oo_JnPbHKZYhlNuIdjMfKpa_xGvXdA,13392
 config2py/tests/test_sync_store.py,sha256=StErw7UeIE01bROkppdyQYKWRgD4Ew5TQ_ZBw4R2wIk,7916
 config2py/tests/test_tools.py,sha256=sdiBNTavuzxW2AsqBRTO9U21iWig5DEyV38r6lmaZak,3728
 config2py/tests/utils_for_testing.py,sha256=-CB1e0l71yknCtKEn5hU3luaTRqrboZwRS4pQo7cGTU,212
-config2py-0.1.45.dist-info/METADATA,sha256=YeSgTmnKEEL6s4U1-al8vvigxLosQ3O9rpzpKiEfgvo,16991
-config2py-0.1.45.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-config2py-0.1.45.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-config2py-0.1.45.dist-info/RECORD,,
+config2py-0.1.46.dist-info/METADATA,sha256=6Bs9Ot8I9XdTXY86XDCOfcndbQnnwUQC6R-oiJ0ASew,18130
+config2py-0.1.46.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+config2py-0.1.46.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+config2py-0.1.46.dist-info/RECORD,,

{config2py-0.1.45.dist-info → config2py-0.1.46.dist-info}/WHEEL

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