extended-data 8.2.0__tar.gz → 8.3.0__tar.gz

extended_data-8.3.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "8.3.0"
+}

{extended_data-8.2.0 → extended_data-8.3.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [8.3.0](https://github.com/jbcom/extended-data/compare/extended-data-v8.2.0...extended-data-v8.3.0) (2026-06-27)
+
+
+### Features
+
+* make ExtendedData the polymorphic container root ([217d8d7](https://github.com/jbcom/extended-data/commit/217d8d7694d26b75c8a0e65979f5b8162a33be9f))
+
 ## [8.2.0](https://github.com/jbcom/extended-data/compare/extended-data-v8.1.0...extended-data-v8.2.0) (2026-06-27)
 
 

{extended_data-8.2.0 → extended_data-8.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: extended-data
-Version: 8.2.0
+Version: 8.3.0
 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
@@ -82,7 +82,8 @@ tiers:
   type coercion, mapping, sequence, and state utilities.
 - Tier 2: `ExtendedData`, `ExtendedString`, `ExtendedDict`, `ExtendedList`,
   `ExtendedTuple`, and `ExtendedSet` containers that expose Tier 1 operations
-  as methods.
+  as methods. `ExtendedData` is the common root and polymorphic constructor for
+  the shape-specific containers.
 - Tier 3: data processors that compose the first two tiers for files, inputs,
   logging, export/import boundaries, and workflows.
 
@@ -115,7 +116,7 @@ payload = ExtendedDict(data).deep_merge({"replicas": 3})
 wrapped = ExtendedData(payload).merge({"owner": "platform"})
 decoded_file = decode_file('{"service": {"name": "worker"}}', suffix="json")
 artifact = DataFile.decode("service:\n  name: api\n", suffix="yaml")
-workflow = DataWorkflow.from_value(wrapped.value).transform("unhump").result()
+workflow = DataWorkflow.from_value(wrapped).transform("unhump").result()
 
 logger.logged_statement("prepared workflow", json_data=workflow.as_builtin(), log_level="info")
 
@@ -142,7 +143,7 @@ extended-data transform --file payload.json --step reconstruct --step unhump
 
 ```text
 extended_data/
-  containers/   Tier 2 ExtendedData and ExtendedString/Dict/List/Tuple/Set wrappers
+  containers/   Tier 2 ExtendedData root plus String/Dict/List/Tuple/Set containers
   inputs/       InputProvider and decorator-based input injection
   io/           Tier 3 file, import, export, and base64 processors
   logging/      structured lifecycle logging
@@ -161,10 +162,12 @@ context values, such as resource IDs, emails, paths, or URLs, must be withheld
 in addition to common secret fields.
 
 Tier 2 containers inherit from standard Python collection primitives and expose
-chainable data operations. `ExtendedData` is the generic facade for any incoming
-value and delegates to shape-specific containers where possible. For example,
-`ExtendedString.decode_json()` promotes JSON into extended containers,
-`ExtendedDict.reconstruct_special_types()` turns string scalars into
+chainable data operations. `ExtendedData` is the polymorphic constructor for any
+incoming value: `ExtendedData({"service": "api"})` is an `ExtendedDict`,
+`ExtendedData(["api"])` is an `ExtendedList`, and `ExtendedData("api")` is an
+`ExtendedString`, while all of them are also `isinstance(value, ExtendedData)`.
+For example, `ExtendedString.decode_json()` promotes JSON into extended
+containers, `ExtendedDict.reconstruct_special_types()` turns string scalars into
 booleans/numbers/dates where safe, and `ExtendedList.first_non_empty()` returns
 the first meaningful value without lowering the surrounding data boundary.
 

{extended_data-8.2.0 → extended_data-8.3.0}/README.md

@@ -10,7 +10,8 @@ tiers:
   type coercion, mapping, sequence, and state utilities.
 - Tier 2: `ExtendedData`, `ExtendedString`, `ExtendedDict`, `ExtendedList`,
   `ExtendedTuple`, and `ExtendedSet` containers that expose Tier 1 operations
-  as methods.
+  as methods. `ExtendedData` is the common root and polymorphic constructor for
+  the shape-specific containers.
 - Tier 3: data processors that compose the first two tiers for files, inputs,
   logging, export/import boundaries, and workflows.
 
@@ -43,7 +44,7 @@ payload = ExtendedDict(data).deep_merge({"replicas": 3})
 wrapped = ExtendedData(payload).merge({"owner": "platform"})
 decoded_file = decode_file('{"service": {"name": "worker"}}', suffix="json")
 artifact = DataFile.decode("service:\n  name: api\n", suffix="yaml")
-workflow = DataWorkflow.from_value(wrapped.value).transform("unhump").result()
+workflow = DataWorkflow.from_value(wrapped).transform("unhump").result()
 
 logger.logged_statement("prepared workflow", json_data=workflow.as_builtin(), log_level="info")
 
@@ -70,7 +71,7 @@ extended-data transform --file payload.json --step reconstruct --step unhump
 
 ```text
 extended_data/
-  containers/   Tier 2 ExtendedData and ExtendedString/Dict/List/Tuple/Set wrappers
+  containers/   Tier 2 ExtendedData root plus String/Dict/List/Tuple/Set containers
   inputs/       InputProvider and decorator-based input injection
   io/           Tier 3 file, import, export, and base64 processors
   logging/      structured lifecycle logging
@@ -89,10 +90,12 @@ context values, such as resource IDs, emails, paths, or URLs, must be withheld
 in addition to common secret fields.
 
 Tier 2 containers inherit from standard Python collection primitives and expose
-chainable data operations. `ExtendedData` is the generic facade for any incoming
-value and delegates to shape-specific containers where possible. For example,
-`ExtendedString.decode_json()` promotes JSON into extended containers,
-`ExtendedDict.reconstruct_special_types()` turns string scalars into
+chainable data operations. `ExtendedData` is the polymorphic constructor for any
+incoming value: `ExtendedData({"service": "api"})` is an `ExtendedDict`,
+`ExtendedData(["api"])` is an `ExtendedList`, and `ExtendedData("api")` is an
+`ExtendedString`, while all of them are also `isinstance(value, ExtendedData)`.
+For example, `ExtendedString.decode_json()` promotes JSON into extended
+containers, `ExtendedDict.reconstruct_special_types()` turns string scalars into
 booleans/numbers/dates where safe, and `ExtendedList.first_non_empty()` returns
 the first meaningful value without lowering the surrounding data boundary.
 

{extended_data-8.2.0 → extended_data-8.3.0}/docs/core/containers.md

@@ -2,8 +2,9 @@
 
 Tier 2 wraps Python data shapes with shape-specific `ExtendedString`,
 `ExtendedDict`, `ExtendedList`, `ExtendedTuple`, and `ExtendedSet` containers.
-Tier 3 starts with `ExtendedData`, a stable facade for callers that do not know
-or should not care which shape is currently inside a payload.
+`ExtendedData` is their common root and polymorphic constructor: callers can use
+one entrypoint while still receiving the concrete extended type for the incoming
+value.
 
 Construction and mutation promote nested values, so method chains survive normal
 Python literals.
@@ -20,27 +21,35 @@ print(payload["tags"].compact().deduplicate())
 print(ExtendedString("HTTP Response Value").to_snake_case())
 ```
 
-## Generic ExtendedData
+## Polymorphic ExtendedData
 
 Use `ExtendedData` at file, API, workflow, and vendor boundaries where the
 payload may be a mapping today, a list tomorrow, or a scalar status value from a
-different provider.
+different provider. The constructor returns the concrete extended subtype when
+one applies, so normal Python collection behavior remains native rather than
+proxied.
 
 ```python
-from extended_data import ExtendedData
+from extended_data import ExtendedData, ExtendedDict, ExtendedList, ExtendedString
 
 vendor = ExtendedData({"vendor": "google", "payload": {"names": ["alpha"]}})
 vendor["enabled"] = "true"
 
+assert type(vendor) is ExtendedDict
+assert isinstance(vendor, ExtendedData)
 assert vendor.shape == "mapping"
 assert vendor.get("vendor").upper_first() == "Google"
 assert vendor["payload"]["names"][0].upper_first() == "Alpha"
 
 merged = vendor.merge({"payload": {"region": "us-east-1"}})
 assert merged.as_builtin()["payload"]["region"] == "us-east-1"
+
+assert type(ExtendedData([{"name": "api"}]).append({"name": "worker"})) is ExtendedList
+assert type(ExtendedData("HTTP Response Value")) is ExtendedString
 ```
 
-The facade exposes broad shape predicates without forcing dict-only code paths:
+The common root exposes broad shape predicates without forcing dict-only code
+paths:
 
 ```python
 assert ExtendedData("HTTP Response Value").is_string

{extended_data-8.2.0 → extended_data-8.3.0}/pyproject.toml

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

{extended_data-8.2.0 → extended_data-8.3.0}/src/extended_data/containers/data.py

@@ -1,61 +1,79 @@
-"""Generic Extended Data container facade."""
+"""Generic Extended Data root and factory."""
 
 from __future__ import annotations
 
-from collections import UserString
 from collections.abc import Callable, Iterable, Iterator, Mapping
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, Self
-
-from extended_data.containers.mappings import ExtendedDict
-from extended_data.containers.sequences import ExtendedList, ExtendedSet, ExtendedTuple
-from extended_data.containers.strings import ExtendedString
+from typing import Any, Self, cast
 
 
 class ExtendedData:
-    """Stable holder for any promoted Extended Data value.
-
-    ``extend_data`` returns the most specific Tier 2 container for a value. This
-    facade is for higher-level code that cannot or should not care whether the
-    current payload is mapping-, sequence-, string-, set-, scalar-, or object-
-    shaped.
+    """Common root and factory for any Extended Data value.
+
+    ``ExtendedData(value)`` returns the most specific concrete Tier 2 container
+    whenever one exists. Mapping values become ``ExtendedDict`` instances, list
+    values become ``ExtendedList`` instances, strings become ``ExtendedString``
+    instances, and so on. Scalars and arbitrary objects remain in a small generic
+    holder so the same workflow, export, and sync helpers are available at file,
+    API, and vendor boundaries.
     """
 
-    __hash__ = None  # type: ignore[assignment]
+    def __new__(cls, value: Any = None) -> Self:
+        """Return the most specific Extended Data object for ``value``."""
+        if cls is not ExtendedData:
+            return super().__new__(cls)
 
-    def __init__(self, value: Any = None) -> None:
-        """Promote and store any supported data shape."""
         from extended_data.containers.factory import extend_data
 
-        self._value = value.value if isinstance(value, ExtendedData) else extend_data(value)
+        promoted = extend_data(value)
+        if isinstance(promoted, ExtendedData):
+            return cast(Self, promoted)
+
+        instance = super().__new__(cls)
+        instance._value = promoted
+        return instance
+
+    def __init__(self, value: Any = None) -> None:
+        """Initialize scalar/object holders without touching concrete subtypes."""
+        if type(self) is ExtendedData and not hasattr(self, "_value"):
+            self._value = value
 
     @property
     def value(self) -> Any:
-        """Return the promoted underlying value."""
-        return self._value
+        """Return the concrete value represented by this object."""
+        if type(self) is ExtendedData:
+            return self._value
+        return self
 
     @property
     def data_type(self) -> str:
-        """Return the promoted value type name."""
-        return type(self._value).__name__
+        """Return this value type name."""
+        return type(self.value).__name__
 
     @property
     def shape(self) -> str:
-        """Return the broad data shape represented by the current value."""
-        if self._value is None:
+        """Return the broad data shape represented by this value."""
+        from collections import UserString
+
+        from extended_data.containers.mappings import ExtendedDict
+        from extended_data.containers.sequences import ExtendedList, ExtendedSet, ExtendedTuple
+        from extended_data.containers.strings import ExtendedString
+
+        value = self.value
+        if value is None:
             return "none"
-        if isinstance(self._value, ExtendedDict | Mapping):
+        if isinstance(value, ExtendedDict | Mapping):
             return "mapping"
-        if isinstance(self._value, ExtendedList | list):
+        if isinstance(value, ExtendedList | list):
             return "list"
-        if isinstance(self._value, ExtendedTuple | tuple):
+        if isinstance(value, ExtendedTuple | tuple):
             return "tuple"
-        if isinstance(self._value, ExtendedSet | set | frozenset):
+        if isinstance(value, ExtendedSet | set | frozenset):
             return "set"
-        if isinstance(self._value, ExtendedString | str | UserString):
+        if isinstance(value, ExtendedString | str | UserString):
             return "string"
-        if isinstance(self._value, bool | int | float | complex | bytes | bytearray | memoryview | Path):
+        if isinstance(value, bool | int | float | complex | bytes | bytearray | memoryview | Path):
             return "scalar"
         return "object"
 
@@ -91,7 +109,7 @@ class ExtendedData:
 
     @classmethod
     def from_value(cls, value: Any = None) -> ExtendedData:
-        """Create an ``ExtendedData`` wrapper from any value."""
+        """Create an Extended Data object from any value."""
         return cls(value)
 
     @classmethod
@@ -102,7 +120,7 @@ class ExtendedData:
         file_path: str | Path | None = None,
         suffix: str | None = None,
     ) -> ExtendedData:
-        """Decode raw structured data and return a generic wrapper."""
+        """Decode raw structured data and return concrete Extended Data."""
         from extended_data.io.files import decode_file
 
         return cls(decode_file(data, file_path=file_path, suffix=suffix, as_extended=True))
@@ -118,7 +136,7 @@ class ExtendedData:
         headers: Mapping[str, str] | None = None,
         tld: Path | None = None,
     ) -> ExtendedData:
-        """Read a local file or URL and return decoded generic data."""
+        """Read a local file or URL and return concrete Extended Data."""
         from extended_data.io.files import read_data_file
 
         return cls(
@@ -137,7 +155,7 @@ class ExtendedData:
         """Return the value lowered to built-in Python containers."""
         from extended_data.containers.factory import to_builtin
 
-        return to_builtin(self._value)
+        return to_builtin(self.value)
 
     def as_extended(self) -> Any:
         """Return a detached promoted copy of the value."""
@@ -146,19 +164,16 @@ class ExtendedData:
         return extend_data(deepcopy(self.as_builtin()))
 
     def copy(self) -> ExtendedData:
-        """Return a detached ``ExtendedData`` copy."""
-        return ExtendedData(deepcopy(self._value))
-
-    def replace(self, value: Any) -> Self:
-        """Replace the underlying value and return this facade."""
-        from extended_data.containers.factory import extend_data
+        """Return a detached Extended Data copy."""
+        return ExtendedData(deepcopy(self.as_builtin()))
 
-        self._value = extend_data(value)
-        return self
+    def cast(self, value: Any) -> ExtendedData:
+        """Return ``value`` promoted into the appropriate Extended Data subtype."""
+        return ExtendedData(value)
 
     def map(self, transform: Callable[[Any], Any]) -> ExtendedData:
-        """Apply a callable to the promoted value and wrap the result."""
-        return ExtendedData(transform(self._value))
+        """Apply a callable to this value and wrap the result."""
+        return ExtendedData(transform(self.value))
 
     def map_builtin(self, transform: Callable[[Any], Any]) -> ExtendedData:
         """Apply a callable to lowered built-in data and wrap the result."""
@@ -168,11 +183,11 @@ class ExtendedData:
         """Apply named DataWorkflow transforms and wrap the result."""
         from extended_data.workflows import DataWorkflow
 
-        return ExtendedData(DataWorkflow.from_value(self._value).transform(*steps).result().value)
+        return ExtendedData(DataWorkflow.from_value(self.value).transform(*steps).result().value)
 
     def merge(self, *mappings: Mapping[str, Any]) -> ExtendedData:
         """Deep-merge mappings when this wrapper contains mapping-shaped data."""
-        method = getattr(self._value, "deep_merge", None)
+        method = getattr(self.value, "deep_merge", None)
         if not callable(method):
             raise TypeError(f"merge is not available for {self.data_type}")
         return ExtendedData(method(*mappings))
@@ -181,7 +196,7 @@ class ExtendedData:
         """Start a DataWorkflow from this value."""
         from extended_data.workflows import DataWorkflow
 
-        return DataWorkflow.from_value(self._value)
+        return DataWorkflow.from_value(self.value)
 
     def sync_to_file(
         self,
@@ -235,24 +250,29 @@ class ExtendedData:
         """Return this value converted to export-safe primitive data."""
         from extended_data.io.exporters import make_raw_data_export_safe
 
-        return make_raw_data_export_safe(self._value, export_to_yaml=export_to_yaml)
+        return make_raw_data_export_safe(self.value, export_to_yaml=export_to_yaml)
 
     def wrap_for_export(self, allow_encoding: bool | str = True, **format_opts: Any) -> str:
         """Return this value wrapped as an encoded export string."""
         from extended_data.io.exporters import wrap_raw_data_for_export
 
-        return wrap_raw_data_for_export(self._value, allow_encoding=allow_encoding, **format_opts)
+        return wrap_raw_data_for_export(self.value, allow_encoding=allow_encoding, **format_opts)
 
     def get(self, key: Any, default: Any = None) -> Any:
         """Return a mapping value by key, or ``default`` when unavailable."""
-        method = getattr(self._value, "get", None)
-        if not callable(method):
+        if not self.is_mapping:
+            return default
+        try:
+            return self[key]
+        except KeyError:
             return default
-        return method(key, default)
 
     def append(self, item: Any) -> Self:
         """Append to list-shaped data and return this wrapper."""
-        method = getattr(self._value, "append", None)
+        value = self.value
+        if value is self:
+            raise TypeError(f"append is not available for {self.data_type}")
+        method = getattr(value, "append", None)
         if not callable(method):
             raise TypeError(f"append is not available for {self.data_type}")
         method(item)
@@ -260,7 +280,10 @@ class ExtendedData:
 
     def extend(self, values: Iterable[Any]) -> Self:
         """Extend list-shaped data and return this wrapper."""
-        method = getattr(self._value, "extend", None)
+        value = self.value
+        if value is self:
+            raise TypeError(f"extend is not available for {self.data_type}")
+        method = getattr(value, "extend", None)
         if not callable(method):
             raise TypeError(f"extend is not available for {self.data_type}")
         method(values)
@@ -268,7 +291,10 @@ class ExtendedData:
 
     def update(self, *args: Any, **kwargs: Any) -> Self:
         """Update mapping- or set-shaped data and return this wrapper."""
-        method = getattr(self._value, "update", None)
+        value = self.value
+        if value is self:
+            raise TypeError(f"update is not available for {self.data_type}")
+        method = getattr(value, "update", None)
         if not callable(method):
             raise TypeError(f"update is not available for {self.data_type}")
         method(*args, **kwargs)
@@ -276,7 +302,10 @@ class ExtendedData:
 
     def add(self, item: Any) -> Self:
         """Add to set-shaped data and return this wrapper."""
-        method = getattr(self._value, "add", None)
+        value = self.value
+        if value is self:
+            raise TypeError(f"add is not available for {self.data_type}")
+        method = getattr(value, "add", None)
         if not callable(method):
             raise TypeError(f"add is not available for {self.data_type}")
         method(item)
@@ -292,47 +321,71 @@ class ExtendedData:
 
     def __iter__(self) -> Iterator[Any]:
         """Iterate the underlying value."""
+        value = self.value
+        if value is self:
+            msg = f"iteration is not available for {self.data_type}"
+            raise TypeError(msg)
         try:
-            return iter(self._value)
+            return iter(value)
         except TypeError:
-            return iter([self._value])
+            return iter([value])
 
     def __len__(self) -> int:
         """Return the underlying value length, or one for scalars."""
+        value = self.value
+        if value is self:
+            msg = f"length is not available for {self.data_type}"
+            raise TypeError(msg)
         try:
-            return len(self._value)
+            return len(value)
         except TypeError:
             return 1
 
     def __bool__(self) -> bool:
         """Mirror the truthiness of the wrapped value."""
-        return bool(self._value)
+        value = self.value
+        if value is self:
+            return len(self) > 0
+        return bool(value)
 
     def __getitem__(self, key: Any) -> Any:
         """Index the underlying value."""
-        return self._value[key]
+        value = self.value
+        if value is self:
+            msg = f"indexing is not available for {self.data_type}"
+            raise TypeError(msg)
+        return value[key]
 
     def __setitem__(self, key: Any, value: Any) -> None:
         """Set an item on mutable underlying data."""
-        self._value[key] = value
+        target = self.value
+        if target is self:
+            msg = f"item assignment is not available for {self.data_type}"
+            raise TypeError(msg)
+        target[key] = value
 
     def __delitem__(self, key: Any) -> None:
         """Delete an item from mutable underlying data."""
-        del self._value[key]
+        value = self.value
+        if value is self:
+            msg = f"item deletion is not available for {self.data_type}"
+            raise TypeError(msg)
+        del value[key]
 
     def __contains__(self, item: object) -> bool:
         """Return whether an item is present in the underlying value."""
+        value = self.value
+        if value is self:
+            try:
+                self[item]
+            except (IndexError, KeyError, TypeError):
+                return False
+            return True
         try:
-            return item in self._value
+            return item in value
         except TypeError:
             return False
 
-    def __eq__(self, other: object) -> bool:
-        """Compare against another facade or raw value by built-in representation."""
-        if isinstance(other, ExtendedData):
-            return self.as_builtin() == other.as_builtin()
-        return self.as_builtin() == other
-
     def __repr__(self) -> str:
         """Return a useful debugging representation."""
-        return f"ExtendedData({self._value!r})"
+        return f"ExtendedData({self.value!r})"

{extended_data-8.2.0 → extended_data-8.3.0}/src/extended_data/containers/factory.py

@@ -15,12 +15,12 @@ def extend_data(value: Any) -> Any:
     """Recursively wrap built-in containers in Extended Data containers."""
     from extended_data.containers.data import ExtendedData
 
-    if isinstance(value, ExtendedData):
-        return value.value
     if isinstance(value, YamlTagged | YamlPairs | LiteralScalarString):
         return value
     if isinstance(value, ExtendedString | ExtendedDict | ExtendedList | ExtendedSet | ExtendedTuple):
         return value
+    if isinstance(value, ExtendedData):
+        return value
     if isinstance(value, str):
         return ExtendedString(value)
     if isinstance(value, Mapping):
@@ -38,8 +38,6 @@ def to_builtin(value: Any) -> Any:
     """Recursively unwrap Extended Data containers to built-in Python values."""
     from extended_data.containers.data import ExtendedData
 
-    if isinstance(value, ExtendedData):
-        return to_builtin(value.value)
     if isinstance(value, YamlTagged | YamlPairs | LiteralScalarString):
         return value
     if isinstance(value, ExtendedString):
@@ -52,6 +50,8 @@ def to_builtin(value: Any) -> Any:
         return tuple(to_builtin(item) for item in value)
     if isinstance(value, ExtendedSet):
         return {to_builtin(item) for item in value}
+    if isinstance(value, ExtendedData):
+        return to_builtin(value.value)
     if isinstance(value, Mapping):
         return {to_builtin(key): to_builtin(item) for key, item in value.items()}
     if isinstance(value, list):

{extended_data-8.2.0 → extended_data-8.3.0}/src/extended_data/containers/mappings.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 
 from collections import UserDict
-from collections.abc import Iterable, Mapping
-from typing import TYPE_CHECKING, Any, Self, overload
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self
 
+from extended_data.containers.data import ExtendedData
 
-if TYPE_CHECKING:
-    from _typeshed import SupportsKeysAndGetItem
 
+if TYPE_CHECKING:
     from extended_data.containers.sequences import ExtendedList, ExtendedTuple
 
 from extended_data.primitives.mappings import (
@@ -26,11 +26,13 @@ from extended_data.primitives.state import all_non_empty_in_dict, any_non_empty,
 from extended_data.primitives.types import reconstruct_special_types
 
 
-class ExtendedDict(UserDict[str, Any]):
+class ExtendedDict(UserDict[str, Any], ExtendedData):
     """Dictionary wrapper with chainable primitive operations."""
 
     def __init__(self, initialdata: Mapping[str, Any] | None = None, **kwargs: Any) -> None:
         """Initialize the extended dictionary."""
+        if initialdata is self and not kwargs:
+            return
         super().__init__()
         self.update(initialdata or {}, **kwargs)
 
@@ -40,22 +42,7 @@ class ExtendedDict(UserDict[str, Any]):
 
         self.data[key] = extend_data(item)
 
-    @overload
-    def update(self, other: SupportsKeysAndGetItem[str, Any], /) -> None: ...
-
-    @overload
-    def update(self, other: SupportsKeysAndGetItem[str, Any], /, **kwargs: Any) -> None: ...
-
-    @overload
-    def update(self, other: Iterable[tuple[str, Any]], /) -> None: ...
-
-    @overload
-    def update(self, other: Iterable[tuple[str, Any]], /, **kwargs: Any) -> None: ...
-
-    @overload
-    def update(self, **kwargs: Any) -> None: ...
-
-    def update(self, *args: Any, **kwargs: Any) -> None:  # type: ignore[misc]
+    def update(self, *args: Any, **kwargs: Any) -> Self:  # type: ignore[override]
         """Update values while preserving extended nested containers."""
         if len(args) > 1:
             msg = f"update expected at most 1 argument, got {len(args)}"
@@ -77,6 +64,8 @@ class ExtendedDict(UserDict[str, Any]):
         for key, value in kwargs.items():
             self[key] = value
 
+        return self
+
     def setdefault(self, key: str, default: Any = None) -> Any:
         """Insert a default while returning the promoted stored value."""
         if key not in self.data: