extended-data 8.4.1__tar.gz → 8.4.2__tar.gz

{extended_data-8.4.1 → extended_data-8.4.2}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [8.4.2](https://github.com/jbcom/extended-data/compare/extended-data-v8.4.1...extended-data-v8.4.2) (2026-06-27)
+
+
+### Bug Fixes
+
+* close doc, autodoc2, and test coverage gaps ([#30](https://github.com/jbcom/extended-data/issues/30)) ([9c577df](https://github.com/jbcom/extended-data/commit/9c577df4e68c0ace888566a981f6054806b0da75))
+
 ## [8.4.1](https://github.com/jbcom/extended-data/compare/extended-data-v8.4.0...extended-data-v8.4.1) (2026-06-27)
 
 

{extended_data-8.4.1 → extended_data-8.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: extended-data
-Version: 8.4.1
+Version: 8.4.2
 Summary: Comprehensive Python data utilities for serialization, inputs, logging, and workflows
 Project-URL: Documentation, https://extended-data.dev
 Project-URL: Issues, https://github.com/jbcom/extended-data/issues

{extended_data-8.4.1 → extended_data-8.4.2}/docs/conf.py

@@ -63,6 +63,6 @@ autodoc2_packages = [
 ]
 autodoc2_render_plugin = "rst"
 autodoc2_docstring_parser_regexes = [(r".*", "myst")]
-autodoc2_hidden_objects = ["inherited", "dunder"]
+autodoc2_hidden_objects = ["inherited", "dunder", "private"]
 autodoc2_class_docstring = "merge"
 autodoc2_module_summary = True

{extended_data-8.4.1 → extended_data-8.4.2}/docs/operations/inputs.rst

@@ -13,7 +13,7 @@ The old directed inputs package is now first-class under
        from_environment=False,
    )
 
-   print(provider.get_input("APP_DEBUG", as_type=bool))
+   print(provider.get_input("APP_DEBUG", is_bool=True))
    print(provider.snapshot_inputs())
 
 Decorators

{extended_data-8.4.1 → extended_data-8.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "extended-data"
-version = "8.4.1"
+version = "8.4.2"
 description = "Comprehensive Python data utilities for serialization, inputs, logging, and workflows"
 requires-python = ">=3.11"
 license = { text = "MIT" }

{extended_data-8.4.1 → extended_data-8.4.2}/src/extended_data/inputs/__init__.py

@@ -7,8 +7,8 @@ various sources like environment variables, stdin, and predefined dictionaries.
 from __future__ import annotations
 
 from extended_data._version import __version__
-from extended_data.inputs.__main__ import InputProvider
 from extended_data.inputs.decorators import directed_inputs, input_config
+from extended_data.inputs.providers import InputProvider
 
 
 __all__ = ["InputProvider", "__version__", "directed_inputs", "input_config"]

{extended_data-8.4.1 → extended_data-8.4.2}/src/extended_data/inputs/decorators.py

@@ -25,7 +25,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
 from extended_data.containers import ExtendedDict, to_builtin
-from extended_data.inputs.__main__ import InputProvider
+from extended_data.inputs.providers import InputProvider
 
 
 if TYPE_CHECKING:

{extended_data-8.4.1 → extended_data-8.4.2}/src/extended_data/primitives/types.py

@@ -17,7 +17,6 @@ Functions:
 
 Classes:
     - ConversionError: Custom error class for handling conversion failures.
-    - ReconstructionError: Custom error class for handling reconstruction failures.
 
 Constants:
     - DATE_PATTERN: Regex for matching ISO 8601 date strings.

{extended_data-8.4.1 → extended_data-8.4.2}/tests/core/test_containers.py

@@ -770,3 +770,92 @@ def test_container_classes_are_root_exports() -> None:
     assert extended_data.ExtendedTuple is ExtendedTuple
     assert extended_data.extend_data is extend_data
     assert extended_data.to_builtin is to_builtin
+
+
+def test_extended_string_transform_methods_round_trip() -> None:
+    """ExtendedString transform bound methods should delegate to Tier 1 primitives."""
+    assert ExtendedString("camelCase").lower_first() == "camelCase"
+    assert ExtendedString("CamelCase").lower_first() == "camelCase"
+    assert ExtendedString("API Response").sanitize() == "API_Response"
+    assert ExtendedString("API Response").sanitize("-") == "API-Response"
+    assert ExtendedString("abcdefghijklmnop").truncate(5) == "ab..."
+    assert ExtendedString("abcdefghijklmnop").truncate(5, ender="!") == "abcd!"
+    assert ExtendedString("api_service").titleize_name() == "Api Service"
+    assert ExtendedString("api response").to_camel_case() == "apiResponse"
+    assert ExtendedString("api response").to_camel_case(uppercase_first=True) == "ApiResponse"
+    assert ExtendedString("api response").to_pascal_case() == "ApiResponse"
+    assert ExtendedString("API Response").pluralize() == "API Responses"
+    assert ExtendedString("API Responses").singularize() == "API Response"
+    assert ExtendedString("api_response").humanize() == "API response"
+    assert ExtendedString("api_response").titleize() == "Api Response"
+
+
+def test_extended_string_is_url_bound_method() -> None:
+    """ExtendedString.is_url should delegate to the Tier 1 url detector."""
+    assert ExtendedString("https://example.com").is_url() is True
+    assert ExtendedString("not a url").is_url() is False
+
+
+def test_extended_dict_unhump_bound_method() -> None:
+    """ExtendedDict.unhump should delegate to unhump_map with prefix option."""
+    value = ExtendedDict({"serviceName": "api", "HTTPResponse": 200})
+    unhumped = value.unhump()
+    assert unhumped == {"service_name": "api", "http_response": 200}
+    assert isinstance(unhumped, ExtendedDict)
+
+    prefixed = ExtendedDict({"v1Service": "api", "v2Other": "x"}).unhump(drop_without_prefix="v1")
+    assert prefixed == {"v1_service": "api"}
+
+
+def test_extended_dict_delitem_succeeds_on_mappings() -> None:
+    """ExtendedData.__delitem__ should delete keys on mutable mappings."""
+    value = ExtendedDict({"service": "api", "region": "us-east-1"})
+    del value["region"]
+    assert "region" not in value
+    assert value == {"service": "api"}
+
+
+def test_reconstruct_special_types_fail_silently_branches() -> None:
+    """reconstruct_special_types(fail_silently=True) should swallow, False should raise."""
+    from extended_data.primitives.types import ConversionError
+
+    bad_yaml = "---\ninvalid: [unclosed"
+    bad = ExtendedList([bad_yaml])
+
+    with pytest.raises(ConversionError):
+        bad.reconstruct_special_types(fail_silently=False)
+
+    silent = bad.reconstruct_special_types(fail_silently=True)
+    assert isinstance(silent, ExtendedList)
+
+    bad_tuple = ExtendedTuple((bad_yaml,))
+    with pytest.raises(ConversionError):
+        bad_tuple.reconstruct_special_types(fail_silently=False)
+    silent_tuple = bad_tuple.reconstruct_special_types(fail_silently=True)
+    assert isinstance(silent_tuple, ExtendedTuple)
+
+    bad_set = ExtendedSet({bad_yaml})
+    with pytest.raises(ConversionError):
+        bad_set.reconstruct_special_types(fail_silently=False)
+    silent_set = bad_set.reconstruct_special_types(fail_silently=True)
+    assert isinstance(silent_set, ExtendedSet)
+
+    bad_dict = ExtendedDict({"key": bad_yaml})
+    with pytest.raises(ConversionError):
+        bad_dict.reconstruct_special_types(fail_silently=False)
+    silent_dict = bad_dict.reconstruct_special_types(fail_silently=True)
+    assert isinstance(silent_dict, ExtendedDict)
+
+
+def test_extended_set_discard_and_copy() -> None:
+    """ExtendedSet.discard and copy should mutate / duplicate as expected."""
+    value = ExtendedSet({"api", "worker", "gateway"})
+    discarded = value.discard("worker")
+    assert discarded is value
+    assert "worker" not in value
+    assert value == {"api", "gateway"}
+
+    copied = value.copy()
+    assert copied == value
+    assert copied is not value
+    assert isinstance(copied, ExtendedSet)

extended_data-8.4.2/tests/core/test_decode_errors.py

@@ -0,0 +1,76 @@
+"""Direct tests for the shared decode-error helpers."""
+
+from __future__ import annotations
+
+from extended_data.primitives.formats.errors import DataDecodeError, invalid_utf8_error
+
+
+def test_from_exception_builds_sanitized_error() -> None:
+    """DataDecodeError.from_exception should translate parser attributes without source snippets."""
+
+    class FakeParserError(Exception):
+        msg = "unexpected token"
+        lineno = 3
+        colno = 12
+
+    err = DataDecodeError.from_exception("YAML", FakeParserError("whatever source text"))
+
+    assert err.format_name == "YAML"
+    assert err.reason == "unexpected token"
+    assert err.line == 3
+    assert err.column == 12
+    message = str(err)
+    assert "Failed to decode YAML data" in message
+    assert "unexpected token" in message
+    assert "line 3" in message
+    assert "column 12" in message
+    assert "whatever source text" not in message
+
+
+def test_from_exception_falls_back_to_type_name_when_no_msg() -> None:
+    """When a parser exposes no msg/problem attr, the reason should be the exception type name."""
+
+    class BareError(Exception):
+        pass
+
+    err = DataDecodeError.from_exception("JSON", BareError())
+
+    assert err.reason == "BareError"
+    assert err.line is None
+    assert err.column is None
+
+
+def test_from_exception_extracts_yaml_problem_mark() -> None:
+    """The YAML parser exposes problem_mark; from_exception should honor it."""
+
+    class Mark:
+        line = 5
+        column = 9
+
+    class YamlishError(Exception):
+        problem_mark = Mark()
+
+    err = DataDecodeError.from_exception("YAML", YamlishError())
+
+    assert err.line == 6
+    assert err.column == 10
+
+
+def test_invalid_utf8_error_returns_data_decode_error() -> None:
+    """invalid_utf8_error should return a DataDecodeError with the canonical reason text."""
+    err = invalid_utf8_error("TOML")
+
+    assert isinstance(err, DataDecodeError)
+    assert err.format_name == "TOML"
+    assert err.reason == "input bytes are not valid UTF-8"
+    assert "input bytes are not valid UTF-8" in str(err)
+
+
+def test_data_decode_error_message_without_reason_or_position() -> None:
+    """A bare DataDecodeError should still render a valid message."""
+    err = DataDecodeError("HCL")
+
+    assert str(err) == "Failed to decode HCL data."
+    assert err.reason is None
+    assert err.line is None
+    assert err.column is None

{extended_data-8.4.1 → extended_data-8.4.2}/tests/core/test_file_data_type.py

@@ -739,6 +739,38 @@ def test_write_file_tfvars_infers_hcl(tmp_path: Path) -> None:
     assert decode_file(content, file_path=test_file) == data
 
 
+def test_write_file_toml(tmp_path: Path) -> None:
+    """TOML encoding should round-trip through write_file and decode_file."""
+    test_file = tmp_path / "config.toml"
+    data = {"service": "api", "replicas": 3, "enabled": True}
+
+    result = write_file(test_file, data, tld=tmp_path)
+
+    assert result == test_file.resolve()
+    assert test_file.exists()
+    content = test_file.read_text()
+    assert 'service = "api"' in content
+    assert "replicas = 3" in content
+    assert decode_file(content, file_path=test_file) == data
+
+
+def test_data_file_toml_round_trip(tmp_path: Path) -> None:
+    """DataFile should preserve TOML data across write then read."""
+    source = tmp_path / "source.toml"
+    source.write_text('service = "api"\nreplicas = 3\n', encoding="utf-8")
+
+    artifact = DataFile.read(source)
+    assert artifact.data == {"service": "api", "replicas": 3}
+    assert artifact.encoding == "toml"
+
+    target = tmp_path / "build" / "out.toml"
+    artifact.write(target, tld=tmp_path)
+
+    reread = DataFile.read(target)
+    assert reread.data == artifact.data
+    assert reread.encoding == "toml"
+
+
 def test_write_file_bytes(tmp_path: Path) -> None:
     """Write raw bytes without re-encoding."""
     test_file = tmp_path / "payload.bin"

extended_data-8.4.2/tests/core/test_normalization.py

@@ -0,0 +1,50 @@
+"""Tests for the internal data normalization helper."""
+
+from __future__ import annotations
+
+from extended_data.containers import ExtendedDict, ExtendedList, ExtendedSet, ExtendedString, ExtendedTuple
+from extended_data.primitives.formats._normalization import lower_extended_data
+
+
+def test_lower_extended_data_unwraps_containers() -> None:
+    """lower_extended_data should lower Tier 2 containers to plain Python values."""
+    value = ExtendedDict(
+        {
+            "service": ExtendedString("api"),
+            "ports": ExtendedList([80, 443]),
+            "tags": ExtendedSet({"prod", "api"}),
+            "aliases": ExtendedTuple(("api", "gateway")),
+        }
+    )
+
+    lowered = lower_extended_data(value)
+
+    assert lowered == {
+        "service": "api",
+        "ports": [80, 443],
+        "tags": {"prod", "api"},
+        "aliases": ("api", "gateway"),
+    }
+    assert type(lowered) is dict
+    assert type(lowered["ports"]) is list
+    assert type(lowered["tags"]) is set
+    assert type(lowered["aliases"]) is tuple
+
+
+def test_lower_extended_data_passes_through_plain_values() -> None:
+    """lower_extended_data should leave plain Python values untouched."""
+    assert lower_extended_data(None) is None
+    assert lower_extended_data(42) == 42
+    assert lower_extended_data("api") == "api"
+    assert lower_extended_data({"service": "api"}) == {"service": "api"}
+
+
+def test_lower_extended_data_unwraps_nested_extended_containers() -> None:
+    """lower_extended_data should recursively lower nested Tier 2 containers."""
+    value = ExtendedDict({"outer": ExtendedDict({"inner": ExtendedList([ExtendedString("api")])})})
+
+    lowered = lower_extended_data(value)
+
+    assert lowered == {"outer": {"inner": ["api"]}}
+    assert type(lowered["outer"]) is dict
+    assert type(lowered["outer"]["inner"]) is list

{extended_data-8.4.1 → extended_data-8.4.2}/tests/core/test_package_cli.py

@@ -269,3 +269,195 @@ def test_transform_can_write_output_artifact(tmp_path) -> None:
     output_text = output.read_text(encoding="utf-8")
     assert _stdout_text(mock_write) == f"{output_text}\n"
     assert "http_response_code: 200" in output_text
+
+
+def test_decode_compact_json_drops_indent() -> None:
+    """--compact should produce single-line JSON without indent."""
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["decode", '{"service": "api"}', "--suffix", "json", "--compact"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert json.loads(output) == {"service": "api"}
+    assert "\n" not in output.strip()
+
+
+def test_decode_non_json_output_ignores_compact() -> None:
+    """--compact only affects JSON; YAML output should remain unchanged."""
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["decode", '{"service": "api"}', "--suffix", "json", "--output", "yaml", "--compact"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "service:" in output
+    assert "api" in output
+
+
+def test_decode_toml_output() -> None:
+    """decode should emit TOML when --output toml is requested."""
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["decode", '{"service": "api", "replicas": 3}', "--suffix", "json", "--output", "toml"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert 'service = "api"' in output
+    assert "replicas = 3" in output
+
+
+def test_decode_hcl_output() -> None:
+    """decode should emit HCL when --output hcl is requested."""
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["decode", '{"locals": [{"region": "us-east-1"}]}', "--suffix", "json", "--output", "hcl"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "locals {" in output
+    assert 'region = "us-east-1"' in output
+
+
+def test_inspect_toml_output(tmp_path) -> None:
+    """inspect should emit TOML metadata when --output toml is requested."""
+    config = tmp_path / "service.json"
+    config.write_text('{"service": "api"}', encoding="utf-8")
+
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["inspect", "--file", str(config), "--output", "toml"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "source" in output
+    assert "json" in output
+
+
+def test_inspect_hcl_output() -> None:
+    """inspect should emit HCL metadata when --output hcl is requested."""
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["inspect", '{"service": "api"}', "--suffix", "json", "--output", "hcl"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "source" in output
+    assert "memory" in output
+
+
+def test_merge_toml_output(tmp_path) -> None:
+    """merge should emit TOML when --output toml is requested."""
+    base = tmp_path / "base.json"
+    env = tmp_path / "env.json"
+    base.write_text('{"service": "api", "replicas": 1}', encoding="utf-8")
+    env.write_text('{"replicas": 3}', encoding="utf-8")
+
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["merge", str(base), str(env), "--output", "toml"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert 'service = "api"' in output
+    assert "replicas = 3" in output
+
+
+def test_merge_hcl_output(tmp_path) -> None:
+    """merge should emit HCL when --output hcl is requested."""
+    base = tmp_path / "base.json"
+    env = tmp_path / "env.json"
+    base.write_text('{"locals": [{"region": "us-east-1"}]}', encoding="utf-8")
+    env.write_text('{"locals": [{"zone": "a"}]}', encoding="utf-8")
+
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(["merge", str(base), str(env), "--output", "hcl"])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "locals {" in output
+
+
+def test_transform_toml_output(tmp_path) -> None:
+    """transform should emit TOML when --output toml is requested."""
+    payload = tmp_path / "payload.json"
+    payload.write_text('{"HTTPResponseCode": "200"}', encoding="utf-8")
+
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(
+            ["transform", "--file", str(payload), "--step", "reconstruct", "--step", "unhump", "--output", "toml"]
+        )
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "http_response_code" in output
+    assert "200" in output
+
+
+def test_transform_hcl_output(tmp_path) -> None:
+    """transform should emit HCL when --output hcl is requested."""
+    payload = tmp_path / "payload.json"
+    payload.write_text('{"locals": [{"region": "us-east-1"}]}', encoding="utf-8")
+
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main(
+            ["transform", "--file", str(payload), "--step", "reconstruct", "--output", "hcl"]
+        )
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "locals {" in output
+
+
+def test_merge_allow_empty_writes_empty_output(tmp_path) -> None:
+    """--allow-empty should let merge write an empty result without error."""
+    base = tmp_path / "base.json"
+    env = tmp_path / "env.json"
+    output = tmp_path / "out.json"
+    base.write_text("{}", encoding="utf-8")
+    env.write_text("{}", encoding="utf-8")
+
+    with patch("sys.stdout.write"):
+        exit_code = cli_module.main(
+            ["merge", str(base), str(env), "--output", "json", "--write", str(output), "--allow-empty"]
+        )
+
+    assert exit_code == 0
+    assert output.exists()
+
+
+def test_transform_allow_empty_writes_empty_output(tmp_path) -> None:
+    """--allow-empty should let transform write an empty result without error."""
+    payload = tmp_path / "payload.json"
+    output = tmp_path / "out.json"
+    payload.write_text("{}", encoding="utf-8")
+
+    with patch("sys.stdout.write"):
+        exit_code = cli_module.main(
+            ["transform", "--file", str(payload), "--step", "compact", "--output", "json", "--write", str(output), "--allow-empty"]
+        )
+
+    assert exit_code == 0
+    assert output.exists()
+
+
+def test_no_command_prints_help_and_returns_zero() -> None:
+    """Calling the CLI with no command should print help and exit 0."""
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main([])
+
+    assert exit_code == 0
+    output = _stdout_text(mock_write)
+    assert "CLI for Extended Data" in output or "usage:" in output.lower()
+
+
+def test_keyboard_interrupt_returns_130() -> None:
+    """KeyboardInterrupt during a command should return exit code 130."""
+    with patch("extended_data.cli.cmd_decode", side_effect=KeyboardInterrupt):
+        exit_code = cli_module.main(["decode", '{"service": "api"}', "--suffix", "json"])
+
+    assert exit_code == 130
+
+
+def test_main_argv_none_reads_sys_argv(monkeypatch) -> None:
+    """main(argv=None) should fall back to sys.argv[1:]."""
+    monkeypatch.setattr("sys.argv", ["extended-data", "decode", '{"x": 1}', "--suffix", "json"])
+
+    with patch("sys.stdout.write") as mock_write:
+        exit_code = cli_module.main()
+
+    assert exit_code == 0
+    assert json.loads(_stdout_text(mock_write)) == {"x": 1}

extended_data-8.4.1/tests/inputs/test_main.py → extended_data-8.4.2/tests/inputs/test_providers.py

@@ -38,8 +38,8 @@ import pytest
 
 from extended_data import base64_encode
 from extended_data.containers import ExtendedDict, ExtendedString
-from extended_data.inputs import __main__ as inputs_module
-from extended_data.inputs.__main__ import InputProvider
+from extended_data.inputs import providers as inputs_module
+from extended_data.inputs.providers import InputProvider
 
 
 @pytest.fixture
@@ -288,6 +288,19 @@ def test_decode_input_base64():
     assert decoded == {"name": "test"}
 
 
+def test_decode_input_base64_then_yaml():
+    """Base64 payload decoded then re-decoded as YAML should produce a mapping."""
+    import yaml
+
+    yaml_payload = yaml.safe_dump({"name": "test", "replicas": 3})
+    encoded_value = base64_encode(yaml_payload.encode())
+    dic = InputProvider(inputs={"base64_key": encoded_value})
+
+    decoded = dic.decode_input("base64_key", decode_from_base64=True, decode_from_yaml=True)
+
+    assert decoded == {"name": "test", "replicas": 3}
+
+
 def test_decode_input_base64_from_bytes():
     """Base64 encoded bytes can be decoded and parsed."""
     encoded_value = base64_encode(json.dumps({"name": "test"}).encode())