kiarina-utils-common 1.0.0__tar.gz

kiarina_utils_common-1.0.0/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg-info/
+dist/
+build/
+.ruff_cache/
+.mypy_cache/
+.pytest_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# uv
+.uv_cache/
+
+# Virtual environments & config
+.venv/
+.env
+
+# IDE
+.vscode/
+*.code-workspace
+
+# OS
+.DS_Store
+
+# Project specific
+*.log
+tmp/
+ai.yaml
+
+# Test data
+tests/data/large/
+
+# mise tasks (always include)
+!mise-tasks/
+!mise-tasks/**

kiarina_utils_common-1.0.0/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to the kiarina-utils-common package will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2025-09-09
+
+### Added
+- Comprehensive README.md with usage examples and API documentation
+- Enhanced pyproject.toml with proper metadata, classifiers, and project URLs
+- CHANGELOG.md for tracking version changes
+
+### Changed
+- Improved package documentation and metadata
+
+## [0.1.0] - 2025-01-09
+
+### Added
+- Initial release of kiarina-utils-common
+- `parse_config_string` function for parsing configuration strings
+- Support for nested keys using dot notation
+- Support for array indices in configuration strings
+- Automatic type conversion (bool, int, float, str)
+- Flag support (keys without values)
+- Customizable separators for different parsing needs
+- Comprehensive test suite with pytest
+- Type hints and py.typed marker for full typing support
+
+### Features
+- Parse configuration strings like `"cache.enabled:true,db.port:5432"`
+- Support for nested structures: `{"cache": {"enabled": True}, "db": {"port": 5432}}`
+- Array index support: `"items.0:first,items.1:second"` → `{"items": ["first", "second"]}`
+- Flag functionality: `"debug,verbose"` → `{"debug": None, "verbose": None}`
+- Custom separators: configurable item, key-value, and nested separators
+- Automatic type detection and conversion for common data types

kiarina_utils_common-1.0.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: kiarina-utils-common
+Version: 1.0.0
+Summary: Common utility functions for the kiarina namespace packages
+Project-URL: Homepage, https://github.com/kiarina/kiarina-python
+Project-URL: Repository, https://github.com/kiarina/kiarina-python
+Project-URL: Issues, https://github.com/kiarina/kiarina-python/issues
+Project-URL: Changelog, https://github.com/kiarina/kiarina-python/blob/main/packages/kiarina-utils-common/CHANGELOG.md
+Project-URL: Documentation, https://github.com/kiarina/kiarina-python/tree/main/packages/kiarina-utils-common#readme
+Author-email: kiarina <kiarinadawa@gmail.com>
+Maintainer-email: kiarina <kiarinadawa@gmail.com>
+License: MIT
+Keywords: common,config,parser,utilities
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# kiarina-utils-common
+
+[![PyPI version](https://badge.fury.io/py/kiarina-utils-common.svg)](https://badge.fury.io/py/kiarina-utils-common)
+[![Python](https://img.shields.io/pypi/pyversions/kiarina-utils-common.svg)](https://pypi.org/project/kiarina-utils-common/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Common utility functions for the kiarina namespace packages.
+
+## Installation
+
+```bash
+pip install kiarina-utils-common
+```
+
+## Features
+
+### Configuration String Parser
+
+Parse configuration strings into nested dictionaries with automatic type conversion.
+
+```python
+from kiarina.utils.common import parse_config_string
+
+# Basic usage
+config = parse_config_string("cache.enabled:true,db.port:5432")
+# Result: {"cache": {"enabled": True}, "db": {"port": 5432}}
+
+# Flag support (no value)
+config = parse_config_string("debug,verbose,cache.enabled:true")
+# Result: {"debug": None, "verbose": None, "cache": {"enabled": True}}
+
+# Array indices support
+config = parse_config_string("items.0:first,items.1:second")
+# Result: {"items": ["first", "second"]}
+
+# Custom separators
+config = parse_config_string(
+    "key1=val1;key2.sub=42", 
+    separator=";", 
+    key_value_separator="="
+)
+# Result: {"key1": "val1", "key2": {"sub": 42}}
+```
+
+#### Type Conversion
+
+Values are automatically converted to appropriate types:
+
+- `"true"`, `"True"` → `bool(True)`
+- `"false"`, `"False"` → `bool(False)`
+- Numeric strings (`"1"`, `"0"`, `"-5"`, `"3.14"`) → `int` or `float`
+- Other strings → `str`
+
+#### Nested Keys
+
+Use dot notation for nested structures:
+
+```python
+config = parse_config_string("database.host:localhost,database.port:5432")
+# Result: {"database": {"host": "localhost", "port": 5432}}
+```
+
+#### Array Indices
+
+Use numeric keys for array structures:
+
+```python
+config = parse_config_string("users.0.name:Alice,users.0.age:30,users.1.name:Bob")
+# Result: {"users": [{"name": "Alice", "age": 30}, {"name": "Bob"}]}
+```
+
+## API Reference
+
+### `parse_config_string(config_str, *, separator=",", key_value_separator=":", nested_separator=".")`
+
+Parse configuration string into nested dictionary.
+
+**Parameters:**
+- `config_str` (str): Configuration string to parse
+- `separator` (str, optional): Item separator. Default: `","`
+- `key_value_separator` (str, optional): Key-value separator. Default: `":"`
+- `nested_separator` (str, optional): Nested key separator. Default: `"."`
+
+**Returns:**
+- `dict[str, Any]`: Parsed configuration dictionary
+
+**Examples:**
+
+```python
+# Basic usage
+parse_config_string("key1:value1,key2:value2")
+# {"key1": "value1", "key2": "value2"}
+
+# Nested keys
+parse_config_string("cache.enabled:true,db.port:5432")
+# {"cache": {"enabled": True}, "db": {"port": 5432}}
+
+# Flags (no value)
+parse_config_string("debug,verbose")
+# {"debug": None, "verbose": None}
+
+# Custom separators
+parse_config_string("a=1;b=2", separator=";", key_value_separator="=")
+# {"a": 1, "b": 2}
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
+
+## Contributing
+
+This is a personal project by kiarina. While issues and pull requests are welcome, please note that this is primarily developed for personal use.
+
+## Related Packages
+
+- [kiarina-utils-file](../kiarina-utils-file/): File operation utilities
+- [kiarina-llm](../kiarina-llm/): LLM-related utilities

kiarina_utils_common-1.0.0/README.md

@@ -0,0 +1,118 @@
+# kiarina-utils-common
+
+[![PyPI version](https://badge.fury.io/py/kiarina-utils-common.svg)](https://badge.fury.io/py/kiarina-utils-common)
+[![Python](https://img.shields.io/pypi/pyversions/kiarina-utils-common.svg)](https://pypi.org/project/kiarina-utils-common/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Common utility functions for the kiarina namespace packages.
+
+## Installation
+
+```bash
+pip install kiarina-utils-common
+```
+
+## Features
+
+### Configuration String Parser
+
+Parse configuration strings into nested dictionaries with automatic type conversion.
+
+```python
+from kiarina.utils.common import parse_config_string
+
+# Basic usage
+config = parse_config_string("cache.enabled:true,db.port:5432")
+# Result: {"cache": {"enabled": True}, "db": {"port": 5432}}
+
+# Flag support (no value)
+config = parse_config_string("debug,verbose,cache.enabled:true")
+# Result: {"debug": None, "verbose": None, "cache": {"enabled": True}}
+
+# Array indices support
+config = parse_config_string("items.0:first,items.1:second")
+# Result: {"items": ["first", "second"]}
+
+# Custom separators
+config = parse_config_string(
+    "key1=val1;key2.sub=42", 
+    separator=";", 
+    key_value_separator="="
+)
+# Result: {"key1": "val1", "key2": {"sub": 42}}
+```
+
+#### Type Conversion
+
+Values are automatically converted to appropriate types:
+
+- `"true"`, `"True"` → `bool(True)`
+- `"false"`, `"False"` → `bool(False)`
+- Numeric strings (`"1"`, `"0"`, `"-5"`, `"3.14"`) → `int` or `float`
+- Other strings → `str`
+
+#### Nested Keys
+
+Use dot notation for nested structures:
+
+```python
+config = parse_config_string("database.host:localhost,database.port:5432")
+# Result: {"database": {"host": "localhost", "port": 5432}}
+```
+
+#### Array Indices
+
+Use numeric keys for array structures:
+
+```python
+config = parse_config_string("users.0.name:Alice,users.0.age:30,users.1.name:Bob")
+# Result: {"users": [{"name": "Alice", "age": 30}, {"name": "Bob"}]}
+```
+
+## API Reference
+
+### `parse_config_string(config_str, *, separator=",", key_value_separator=":", nested_separator=".")`
+
+Parse configuration string into nested dictionary.
+
+**Parameters:**
+- `config_str` (str): Configuration string to parse
+- `separator` (str, optional): Item separator. Default: `","`
+- `key_value_separator` (str, optional): Key-value separator. Default: `":"`
+- `nested_separator` (str, optional): Nested key separator. Default: `"."`
+
+**Returns:**
+- `dict[str, Any]`: Parsed configuration dictionary
+
+**Examples:**
+
+```python
+# Basic usage
+parse_config_string("key1:value1,key2:value2")
+# {"key1": "value1", "key2": "value2"}
+
+# Nested keys
+parse_config_string("cache.enabled:true,db.port:5432")
+# {"cache": {"enabled": True}, "db": {"port": 5432}}
+
+# Flags (no value)
+parse_config_string("debug,verbose")
+# {"debug": None, "verbose": None}
+
+# Custom separators
+parse_config_string("a=1;b=2", separator=";", key_value_separator="=")
+# {"a": 1, "b": 2}
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
+
+## Contributing
+
+This is a personal project by kiarina. While issues and pull requests are welcome, please note that this is primarily developed for personal use.
+
+## Related Packages
+
+- [kiarina-utils-file](../kiarina-utils-file/): File operation utilities
+- [kiarina-llm](../kiarina-llm/): LLM-related utilities

kiarina_utils_common-1.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "kiarina-utils-common"
+version = "1.0.0"
+description = "Common utility functions for the kiarina namespace packages"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "kiarina", email = "kiarinadawa@gmail.com" }
+]
+maintainers = [
+    { name = "kiarina", email = "kiarinadawa@gmail.com" }
+]
+keywords = ["utilities", "config", "parser", "common"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/kiarina/kiarina-python"
+Repository = "https://github.com/kiarina/kiarina-python"
+Issues = "https://github.com/kiarina/kiarina-python/issues"
+Changelog = "https://github.com/kiarina/kiarina-python/blob/main/packages/kiarina-utils-common/CHANGELOG.md"
+Documentation = "https://github.com/kiarina/kiarina-python/tree/main/packages/kiarina-utils-common#readme"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kiarina"]

kiarina_utils_common-1.0.0/src/kiarina/utils/common/__init__.py

@@ -0,0 +1,10 @@
+# pip install kiarina-utils-common
+from importlib.metadata import version
+
+from ._parse_config_string import parse_config_string
+
+__version__ = version("kiarina-utils-common")
+
+__all__ = [
+    "parse_config_string",
+]

kiarina_utils_common-1.0.0/src/kiarina/utils/common/_parse_config_string.py

@@ -0,0 +1,216 @@
+from typing import Any
+
+
+def parse_config_string(
+    config_str: str,
+    *,
+    separator: str = ",",
+    key_value_separator: str = ":",
+    nested_separator: str = ".",
+) -> dict[str, Any]:
+    """
+    Parse configuration string into nested dictionary
+
+    When key contains nested_separator, it will be treated as nested keys:
+    - hoge.fuga:30 → {"hoge": {"fuga": 30}}
+
+    When key_value_separator is not found, the key is treated as a flag with None value:
+    - debug,enabled:true → {"debug": None, "enabled": True}
+
+    Values are automatically converted to appropriate types:
+    - "true", "True" → bool(True)
+    - "false", "False" → bool(False)
+    - Numeric strings ("1", "0", "-5", etc.) → int/float
+    - Others → str
+
+    Args:
+        config_str: Configuration string to parse
+        separator: Item separator (default: ",")
+        key_value_separator: Key-value separator (default: ":")
+        nested_separator: Nested key separator (default: ".")
+
+    Returns:
+        Parsed configuration dictionary
+
+    Examples:
+        >>> parse_config_string("cache.enabled:true,db.port:5432")
+        {"cache": {"enabled": True}, "db": {"port": 5432}}
+
+        >>> parse_config_string("debug,verbose,cache.enabled:true")
+        {"debug": None, "verbose": None, "cache": {"enabled": True}}
+
+        >>> parse_config_string("key1=val1;key2.sub=42", separator=";", key_value_separator="=")
+        {"key1": "val1", "key2": {"sub": 42}}
+    """
+    if not config_str:
+        return {}
+
+    result: dict[str, Any] = {}
+
+    for option in config_str.split(separator):
+        option = option.strip()
+
+        if not option:
+            continue
+
+        if key_value_separator in option:
+            key, value = option.split(key_value_separator, 1)
+            key = key.strip()
+            value = value.strip()
+
+            converted_value = _convert_value(value)
+
+            # Handle nested keys
+            _set_nested_value(result, key, converted_value, nested_separator)
+        else:
+            # No key_value_separator found, treat as flag with None value
+            _set_nested_value(result, option, None, nested_separator)
+
+    return result
+
+
+def _convert_value(value: str) -> Any:
+    """
+    Convert string value to appropriate type
+
+    Args:
+        value: String value to convert
+
+    Returns:
+        Converted value
+    """
+    try:
+        # Boolean values (only true and false, 1 and 0 are treated as numbers)
+        if value.lower() == "true":
+            return True
+
+        elif value.lower() == "false":
+            return False
+
+        # Integer case
+        elif value.lstrip("-").isdigit():
+            return int(value)
+
+        # Floating point case
+        else:
+            try:
+                float_value = float(value)
+
+                # Don't convert to integer if it can be represented as integer (respect original value)
+                if "." in value:
+                    return float_value
+                else:
+                    # If integer format but not caught above, treat as string
+                    return value
+
+            except ValueError:
+                # String case
+                return value
+
+    except (ValueError, TypeError):
+        # If conversion fails, save as string
+        return value
+
+
+def _set_nested_value(
+    target: dict[str, Any], key: str, value: Any, separator: str = "."
+) -> None:
+    """
+    Set value with nested keys (supports array indices)
+
+    When a key is a numeric string, it's treated as an array index:
+    - items.0:foo → {"items": ["foo"]}
+    - users.0.name:Alice → {"users": [{"name": "Alice"}]}
+
+    Args:
+        target: Target dictionary to set the value
+        key: Key (supports dot notation and array indices)
+        value: Value to set
+        separator: Nested key separator (default: ".")
+    """
+    keys = key.split(separator)
+
+    current: dict[str, Any] | list[Any] = target
+
+    # Navigate/create nested structure up to the last key
+    for i, k in enumerate(keys[:-1]):
+        next_key = keys[i + 1]
+
+        if _is_array_index(k):
+            index = int(k)
+
+            if not isinstance(current, list):
+                raise ValueError(
+                    f"Cannot access array index {index} on non-array value"
+                )
+
+            while len(current) <= index:
+                current.append(None)
+
+            if _is_array_index(next_key):
+                if current[index] is None:
+                    current[index] = []
+                elif not isinstance(current[index], list):
+                    current[index] = []
+
+            else:
+                if current[index] is None:
+                    current[index] = {}
+                elif not isinstance(current[index], dict):
+                    current[index] = {}
+
+            current = current[index]
+
+        else:
+            if not isinstance(current, dict):
+                raise ValueError(f"Cannot access key '{k}' on non-dict value")
+
+            if _is_array_index(next_key):
+                if k not in current:
+                    current[k] = []
+                elif not isinstance(current[k], list):
+                    current[k] = []
+
+                current = current[k]
+
+            else:
+                if k not in current:
+                    current[k] = {}
+                elif not isinstance(current[k], dict):
+                    current[k] = {}
+
+                current = current[k]
+
+    # Set the value for the last key
+    last_key = keys[-1]
+
+    if _is_array_index(last_key):
+        index = int(last_key)
+
+        if not isinstance(current, list):
+            raise ValueError(f"Cannot set array index {index} on non-array value")
+
+        # Extend list if necessary (fill with None)
+        while len(current) <= index:
+            current.append(None)
+
+        current[index] = value
+
+    else:
+        if not isinstance(current, dict):
+            raise ValueError(f"Cannot set key '{last_key}' on non-dict value")
+
+        current[last_key] = value
+
+
+def _is_array_index(key: str) -> bool:
+    """
+    Check if a key represents an array index
+
+    Args:
+        key: Key to check
+
+    Returns:
+        True if key is a non-negative integer string
+    """
+    return key.isdigit()

kiarina_utils_common-1.0.0/tests/test_parse_config_string.py

@@ -0,0 +1,296 @@
+import pytest
+
+from kiarina.utils.common import parse_config_string
+
+
+def test_parse_config_string_empty():
+    """Test empty configuration string"""
+    result = parse_config_string("")
+    assert result == {}
+
+
+@pytest.mark.parametrize(
+    "config_str,expected",
+    [
+        # Basic key-value pairs
+        ("key1:value1,key2:value2", {"key1": "value1", "key2": "value2"}),
+        ("single:option", {"single": "option"}),
+        # Flag functionality (no key_value_separator)
+        ("debug", {"debug": None}),
+        ("debug,verbose", {"debug": None, "verbose": None}),
+        ("debug,enabled:true", {"debug": None, "enabled": True}),
+        (
+            "debug,verbose,cache.enabled:true",
+            {"debug": None, "verbose": None, "cache": {"enabled": True}},
+        ),
+        # Type conversion
+        ("bool_true:true", {"bool_true": True}),
+        ("bool_false:false", {"bool_false": False}),
+        ("bool_True:True", {"bool_True": True}),
+        ("bool_False:False", {"bool_False": False}),
+        ("int_pos:123", {"int_pos": 123}),
+        ("int_neg:-456", {"int_neg": -456}),
+        ("int_zero:0", {"int_zero": 0}),
+        ("float_pos:3.14", {"float_pos": 3.14}),
+        ("float_neg:-2.5", {"float_neg": -2.5}),
+        ("str_val:hello", {"str_val": "hello"}),
+        # Mixed types
+        (
+            "bool:true,int:42,float:3.14,str:hello",
+            {"bool": True, "int": 42, "float": 3.14, "str": "hello"},
+        ),
+    ],
+)
+def test_parse_config_string_basic(config_str, expected):
+    """Test basic configuration string parsing and type conversion"""
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "config_str,expected",
+    [
+        # Simple nesting
+        ("cache.enabled:true", {"cache": {"enabled": True}}),
+        ("db.port:5432", {"db": {"port": 5432}}),
+        # Nested flags
+        ("app.debug", {"app": {"debug": None}}),
+        ("app.debug,app.verbose", {"app": {"debug": None, "verbose": None}}),
+        ("app.debug,app.port:8080", {"app": {"debug": None, "port": 8080}}),
+        # Multiple nested keys
+        (
+            "cache.enabled:true,cache.ttl:3600",
+            {"cache": {"enabled": True, "ttl": 3600}},
+        ),
+        # Different sections
+        (
+            "cache.enabled:true,db.host:localhost,db.port:5432",
+            {"cache": {"enabled": True}, "db": {"host": "localhost", "port": 5432}},
+        ),
+        # Deep nesting
+        ("a.b.c.d:value1", {"a": {"b": {"c": {"d": "value1"}}}}),
+        # Mixed depth nesting with flags
+        (
+            "a.b.c.d:value1,a.b.e:value2,a.f:value3,a.b.flag",
+            {
+                "a": {
+                    "b": {"c": {"d": "value1"}, "e": "value2", "flag": None},
+                    "f": "value3",
+                }
+            },
+        ),
+    ],
+)
+def test_parse_config_string_nested(config_str, expected):
+    """Test nested key parsing with dot notation"""
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "config_str,expected",
+    [
+        # Whitespace around options
+        ("  key1:value1  ,  key2:value2  ", {"key1": "value1", "key2": "value2"}),
+        # Whitespace around key-value pairs
+        ("key1  :  value1", {"key1": "value1"}),
+        # Whitespace with nested keys
+        ("  key1.nested  :  42  ", {"key1": {"nested": 42}}),
+        # Mixed whitespace
+        (
+            "  cache.enabled : true , db.port : 5432  ",
+            {"cache": {"enabled": True}, "db": {"port": 5432}},
+        ),
+    ],
+)
+def test_parse_config_string_whitespace(config_str, expected):
+    """Test whitespace handling in keys and values"""
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "config_str,separator,key_value_separator,nested_separator,expected",
+    [
+        # Custom item separator
+        (
+            "key1=value1;key2=value2",
+            ";",
+            "=",
+            ".",
+            {"key1": "value1", "key2": "value2"},
+        ),
+        # Custom key-value separator with nesting
+        (
+            "key1=value1;key2.sub=42",
+            ";",
+            "=",
+            ".",
+            {"key1": "value1", "key2": {"sub": 42}},
+        ),
+        # Custom nested separator
+        (
+            "key1/sub:value1,key2/nested/deep:42",
+            ",",
+            ":",
+            "/",
+            {"key1": {"sub": "value1"}, "key2": {"nested": {"deep": 42}}},
+        ),
+        # All custom separators
+        (
+            "app|debug=true;app|port=8080",
+            ";",
+            "=",
+            "|",
+            {"app": {"debug": True, "port": 8080}},
+        ),
+    ],
+)
+def test_parse_config_string_custom_separators(
+    config_str, separator, key_value_separator, nested_separator, expected
+):
+    """Test custom separators"""
+    result = parse_config_string(
+        config_str,
+        separator=separator,
+        key_value_separator=key_value_separator,
+        nested_separator=nested_separator,
+    )
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "config_str,expected",
+    [
+        # Options without key-value separator are now treated as flags
+        ("debug,valid:value", {"debug": None, "valid": "value"}),
+        ("flag1,key1:value1,flag2", {"flag1": None, "key1": "value1", "flag2": None}),
+        # Empty options (should be ignored)
+        ("key1:value1,,key2:value2", {"key1": "value1", "key2": "value2"}),
+        # Mixed flags and values with empty options
+        ("debug,,verbose,port:8080,", {"debug": None, "verbose": None, "port": 8080}),
+        # Whitespace handling with flags
+        (
+            "  debug  ,  verbose  ,  port : 8080  ",
+            {"debug": None, "verbose": None, "port": 8080},
+        ),
+    ],
+)
+def test_parse_config_string_edge_cases(config_str, expected):
+    """Test edge cases and error handling"""
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "config_str,expected",
+    [
+        # Simple array
+        ("items.0:foo,items.1:bar,items.2:baz", {"items": ["foo", "bar", "baz"]}),
+        ("tags.0:python,tags.1:rust", {"tags": ["python", "rust"]}),
+        # Array with type conversion
+        ("numbers.0:1,numbers.1:2,numbers.2:3", {"numbers": [1, 2, 3]}),
+        ("mixed.0:1,mixed.1:true,mixed.2:hello", {"mixed": [1, True, "hello"]}),
+        # Sparse array (with None gaps)
+        ("sparse.0:first,sparse.2:third", {"sparse": ["first", None, "third"]}),
+        # Nested structure with arrays
+        (
+            "users.0.name:Alice,users.0.age:30,users.1.name:Bob,users.1.age:25",
+            {"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]},
+        ),
+        # Mixed arrays and regular keys
+        (
+            "app.name:myapp,app.tags.0:web,app.tags.1:api,app.debug:true",
+            {"app": {"name": "myapp", "tags": ["web", "api"], "debug": True}},
+        ),
+        # Array in nested structure
+        (
+            "db.servers.0:localhost,db.servers.1:192.168.1.1,db.port:5432",
+            {"db": {"servers": ["localhost", "192.168.1.1"], "port": 5432}},
+        ),
+        # Deep nesting with arrays
+        (
+            "config.db.hosts.0:primary,config.db.hosts.1:secondary",
+            {"config": {"db": {"hosts": ["primary", "secondary"]}}},
+        ),
+    ],
+)
+def test_parse_config_string_arrays(config_str, expected):
+    """Test array support with index notation"""
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "config_str,expected",
+    [
+        # Array flags (no values)
+        ("items.0,items.1:value", {"items": [None, "value"]}),
+        ("flags.0,flags.1,flags.2", {"flags": [None, None, None]}),
+        # Mixed flags and arrays
+        (
+            "debug,items.0:first,verbose,items.1:second",
+            {"debug": None, "items": ["first", "second"], "verbose": None},
+        ),
+    ],
+)
+def test_parse_config_string_array_flags(config_str, expected):
+    """Test array support with flag notation"""
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+def test_parse_config_string_array_edge_cases():
+    """Test edge cases for array functionality"""
+    # Single element array
+    result = parse_config_string("items.0:single")
+    assert result == {"items": ["single"]}
+
+    # Large index (creates sparse array)
+    result = parse_config_string("items.10:value")
+    expected_items = [None] * 10 + ["value"]
+    assert result == {"items": expected_items}
+
+    # Zero index
+    result = parse_config_string("items.0:zero")
+    assert result == {"items": ["zero"]}
+
+
+def test_parse_config_string_array_type_conflicts():
+    """Test handling of type conflicts with arrays"""
+    # When dict key comes first, then array index - dict gets converted to array
+    result = parse_config_string("items.key:value,items.0:first")
+    # The dict gets converted to array, losing the original key
+    assert result == {"items": ["first"]}
+
+    # When array index comes first, then dict key - array gets converted to dict
+    result = parse_config_string("items.0:first,items.key:value")
+    # The array gets converted to dict, preserving both values
+    assert result == {"items": {"key": "value"}}
+
+
+def test_parse_config_string_real_world_example():
+    """Test real-world application configuration example"""
+    config_str = "app.debug:true,app.port:8080,app.name:myapp,db.host:localhost,db.port:5432,db.timeout:30.5,cache.enabled:true,cache.ttl:3600"
+
+    expected = {
+        "app": {"debug": True, "port": 8080, "name": "myapp"},
+        "db": {"host": "localhost", "port": 5432, "timeout": 30.5},
+        "cache": {"enabled": True, "ttl": 3600},
+    }
+
+    result = parse_config_string(config_str)
+    assert result == expected
+
+
+def test_parse_config_string_real_world_with_arrays():
+    """Test real-world configuration with arrays"""
+    config_str = "app.name:myapp,app.tags.0:web,app.tags.1:api,db.servers.0:primary,db.servers.1:secondary,db.ports.0:5432,db.ports.1:5433"
+
+    expected = {
+        "app": {"name": "myapp", "tags": ["web", "api"]},
+        "db": {"servers": ["primary", "secondary"], "ports": [5432, 5433]},
+    }
+
+    result = parse_config_string(config_str)
+    assert result == expected