omegaconf 2.4.0.dev12__tar.gz → 2.4.0.dev13__tar.gz

{omegaconf-2.4.0.dev12/omegaconf.egg-info → omegaconf-2.4.0.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omegaconf
-Version: 2.4.0.dev12
+Version: 2.4.0.dev13
 Summary: A flexible configuration library
 Home-page: https://github.com/omry/omegaconf
 Author: Omry Yadan

{omegaconf-2.4.0.dev12 → omegaconf-2.4.0.dev13}/omegaconf/__init__.py

@@ -30,6 +30,7 @@ from .omegaconf import (
     open_dict,
     read_write,
 )
+from .tupleconfig import TupleConfig
 from .typing import Antlr4ParserRuleContext
 from .version import __version__
 
@@ -43,6 +44,7 @@ __all__ = [
     "Container",
     "UnionNode",
     "ListConfig",
+    "TupleConfig",
     "DictConfig",
     "DictKeyType",
     "OmegaConf",

{omegaconf-2.4.0.dev12 → omegaconf-2.4.0.dev13}/omegaconf/_impl.py

@@ -1,13 +1,18 @@
 from typing import Any
 
-from omegaconf import Container, DictConfig, ListConfig, Node, ValueNode
-from omegaconf.errors import ConfigKeyError, ConfigTypeError
+from omegaconf import Container, DictConfig, ListConfig, Node, TupleConfig, ValueNode
+from omegaconf.errors import (
+    ConfigKeyError,
+    ConfigTypeError,
+    InterpolationToMissingValueError,
+)
 from omegaconf.nodes import InterpolationResultNode
 
 from ._utils import (
     _DEFAULT_MARKER_,
     _ensure_container,
     _get_value,
+    _is_missing_literal,
     is_primitive_container,
     is_structured_config,
 )
@@ -26,8 +31,19 @@ def _resolve_container_value(cfg: Container, key: Any) -> None:
                 resolved_value
             ):
                 resolved = _ensure_container(resolved_value)
+        if isinstance(cfg, TupleConfig) and _is_missing_literal(_get_value(resolved)):
+            cfg._format_and_raise(
+                key=key,
+                value=_get_value(resolved),
+                cause=InterpolationToMissingValueError(
+                    "TupleConfig interpolation resolved to a missing value"
+                ),
+            )
         if isinstance(resolved, Container) and isinstance(node, ValueNode):
-            cfg[key] = resolved
+            if isinstance(cfg, TupleConfig):
+                cfg._set_item_for_resolution(key, resolved)
+            else:
+                cfg[key] = resolved
         else:
             node._set_value(_get_value(resolved))
     else:
@@ -44,7 +60,7 @@ def _resolve(cfg: Node) -> Node:
         for k in list(cfg.keys()):
             _resolve_container_value(cfg, k)
 
-    elif isinstance(cfg, ListConfig):
+    elif isinstance(cfg, (ListConfig, TupleConfig)):
         for i in range(len(cfg)):
             _resolve_container_value(cfg, i)
 

{omegaconf-2.4.0.dev12 → omegaconf-2.4.0.dev13}/omegaconf/_utils.py

@@ -131,6 +131,7 @@ _DEFAULT_MARKER_: Any = Marker("_DEFAULT_MARKER_")
 class OmegaConfDumper(BaseDumper):  # type: ignore
     str_representer_added = False
     pathlib_representers_added = False
+    tuple_representer_added = False
 
     @staticmethod
     def str_representer(dumper: yaml.Dumper, data: str) -> yaml.ScalarNode:
@@ -166,6 +167,12 @@ class OmegaConfDumper(BaseDumper):  # type: ignore
             [str(data)],
         )
 
+    @staticmethod
+    def tuple_representer(dumper: yaml.Dumper, data: Any) -> yaml.Node:
+        return dumper.represent_sequence(
+            yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG, data
+        )
+
 
 def get_omega_conf_dumper() -> Type[OmegaConfDumper]:
     if not OmegaConfDumper.str_representer_added:
@@ -186,6 +193,10 @@ def get_omega_conf_dumper() -> Type[OmegaConfDumper]:
         )
         OmegaConfDumper.pathlib_representers_added = True
 
+    if not OmegaConfDumper.tuple_representer_added:
+        OmegaConfDumper.add_representer(tuple, OmegaConfDumper.tuple_representer)
+        OmegaConfDumper.tuple_representer_added = True
+
     return OmegaConfDumper
 
 
@@ -742,12 +753,45 @@ def get_list_element_type(ref_type: Optional[Type[Any]]) -> Any:
 
 def get_tuple_item_types(ref_type: Type[Any]) -> Tuple[Any, ...]:
     args = getattr(ref_type, "__args__", None)
-    if args in (None, ()):
+    if ref_type in (tuple, Tuple) or args is None:
         args = (Any, ...)
+    elif args == ((),):
+        args = ()
     assert isinstance(args, tuple)
     return args
 
 
+def normalize_tuple_annotation(ref_type: Any) -> Any:
+    if not is_tuple_annotation(ref_type):
+        raise ValidationError(f"Unsupported tuple type: '{type_str(ref_type)}'")
+
+    if ref_type in (tuple, Tuple):
+        return Tuple[Any, ...]
+
+    args = get_tuple_item_types(ref_type)
+    if Ellipsis in args and not (len(args) == 2 and args[1] is Ellipsis):
+        raise ValidationError(f"Unsupported tuple type: '{type_str(ref_type)}'")
+
+    for item_type in args:
+        origin = getattr(item_type, "__origin__", None)
+        if (
+            getattr(origin, "__module__", None),
+            getattr(origin, "__qualname__", None),
+        ) in (("typing", "Unpack"), ("typing_extensions", "Unpack")):
+            raise ValidationError(f"Unsupported tuple type: '{type_str(ref_type)}'")
+
+    return ref_type
+
+
+def is_variadic_tuple_annotation(ref_type: Any) -> bool:
+    args = get_tuple_item_types(normalize_tuple_annotation(ref_type))
+    return len(args) == 2 and args[1] is Ellipsis
+
+
+def make_tuple_annotation(item_types: Tuple[Any, ...]) -> Any:
+    return Tuple[item_types]  # type: ignore[valid-type]
+
+
 def get_dict_key_value_types(ref_type: Any) -> Tuple[Any, Any]:
     args = getattr(ref_type, "__args__", None)
     if args is None:
@@ -1043,14 +1087,14 @@ def _ensure_container(target: Any, flags: Optional[Dict[str, bool]] = None) -> A
     from omegaconf import OmegaConf
 
     if is_primitive_container(target):
-        assert isinstance(target, (list, dict))
+        assert isinstance(target, (list, tuple, dict))
         target = OmegaConf.create(target, flags=flags)
     elif is_structured_config(target):
         target = OmegaConf.structured(target, flags=flags)
     elif not OmegaConf.is_config(target):
         raise ValueError(
             "Invalid input. Supports one of "
-            + "[dict,list,DictConfig,ListConfig,dataclass,dataclass instance,attr class,attr class instance]"
+            + "[dict,list,tuple,DictConfig,ListConfig,TupleConfig,dataclass,dataclass instance,attr class,attr class instance]"
         )
 
     return target
@@ -1083,7 +1127,11 @@ def is_generic_dict(type_: Any) -> bool:
 
 
 def is_container_annotation(type_: Any) -> bool:
-    return is_list_annotation(type_) or is_dict_annotation(type_)
+    return (
+        is_list_annotation(type_)
+        or is_tuple_annotation(type_)
+        or is_dict_annotation(type_)
+    )
 
 
 # Characters recognised after a backslash in key paths and dotlist entries.

{omegaconf-2.4.0.dev12 → omegaconf-2.4.0.dev13}/omegaconf/base.py

@@ -30,6 +30,7 @@ from ._utils import (
     get_value_kind,
     is_dict_annotation,
     is_list_annotation,
+    is_tuple_annotation,
     is_union_annotation,
     is_valid_value_annotation,
     split_key,
@@ -377,7 +378,7 @@ class Node(ABC):
 class Box(Node):
     """
     Base class for nodes that can contain other nodes.
-    Concrete subclasses include DictConfig, ListConfig, and UnionNode.
+    Concrete subclasses include DictConfig, ListConfig, TupleConfig, and UnionNode.
     """
 
     _content: Any
@@ -393,6 +394,7 @@ class Box(Node):
     def _re_parent(self) -> None:
         from .dictconfig import DictConfig
         from .listconfig import ListConfig
+        from .tupleconfig import TupleConfig
 
         # update parents of first level Config nodes to self
 
@@ -404,7 +406,7 @@ class Box(Node):
                         value._set_parent(self)
                     if isinstance(value, Box):
                         value._re_parent()
-        elif isinstance(self, ListConfig):
+        elif isinstance(self, (ListConfig, TupleConfig)):
             content = self.__dict__["_content"]
             if isinstance(content, list):
                 for item in self.__dict__["_content"]:
@@ -844,6 +846,7 @@ class Container(Box):
     def _invalidate_flags_cache(self) -> None:
         from .dictconfig import DictConfig
         from .listconfig import ListConfig
+        from .tupleconfig import TupleConfig
 
         # invalidate subtree cache only if the cache is initialized in this node.
 
@@ -854,7 +857,7 @@ class Container(Box):
                 if isinstance(content, dict):
                     for value in self.__dict__["_content"].values():
                         value._invalidate_flags_cache()
-            elif isinstance(self, ListConfig):
+            elif isinstance(self, (ListConfig, TupleConfig)):
                 content = self.__dict__["_content"]
                 if isinstance(content, list):
                     for item in self.__dict__["_content"]:
@@ -969,6 +972,7 @@ class UnionNode(Box):
     ) -> None:
         from omegaconf.listconfig import ListConfig
         from omegaconf.omegaconf import _node_wrap
+        from omegaconf.tupleconfig import TupleConfig
 
         ref_type = self._metadata.ref_type
         type_hint = self._metadata.type_hint
@@ -982,12 +986,25 @@ class UnionNode(Box):
                         f"Value '$VALUE' is incompatible with type hint '{type_str(type_hint)}'"
                     )
             self.__dict__["_content"] = value
-        elif isinstance(value, (list, tuple, ListConfig)):
-            # Only try List[...] candidates — keeps primitive members out of container
-            # dispatch and makes ambiguity an error instead of silent first-match.
+        elif isinstance(value, (list, tuple, ListConfig, TupleConfig)):
+            sequence_candidates = [
+                t
+                for t in ref_type.__args__
+                if is_list_annotation(t) or is_tuple_annotation(t)
+            ]
+            input_is_tuple = isinstance(value, (tuple, TupleConfig))
+            preferred_candidates = [
+                t
+                for t in sequence_candidates
+                if is_tuple_annotation(t) == input_is_tuple
+            ]
+            fallback_candidates = [
+                t for t in sequence_candidates if t not in preferred_candidates
+            ]
             self._set_container_value(
                 value=value,
-                candidates=[t for t in ref_type.__args__ if is_list_annotation(t)],
+                candidates=preferred_candidates,
+                fallback_candidates=fallback_candidates,
                 type_hint=type_hint,
             )
         elif isinstance(value, (dict, Container)):
@@ -1020,48 +1037,79 @@ class UnionNode(Box):
         value: Any,
         candidates: List[Any],
         type_hint: Any,
+        fallback_candidates: Optional[List[Any]] = None,
     ) -> None:
         from omegaconf.listconfig import ListConfig
         from omegaconf.omegaconf import _node_wrap
+        from omegaconf.tupleconfig import TupleConfig
 
-        from ._utils import get_dict_key_value_types, get_list_element_type
+        from ._utils import (
+            get_dict_key_value_types,
+            get_list_element_type,
+            get_tuple_item_types,
+            normalize_tuple_annotation,
+        )
 
         # For an already-typed container (from typed_list/typed_dict or another
         # structured config), use its element-type metadata to narrow candidates
         # before falling back to content-based validation. This makes empty
         # containers unambiguous when the metadata uniquely identifies one branch.
-        if isinstance(value, ListConfig) and value._metadata.element_type is not Any:
-            meta_candidates = [
-                t
-                for t in candidates
-                if get_list_element_type(t) == value._metadata.element_type
-            ]
-            if meta_candidates:
-                candidates = meta_candidates
-        elif isinstance(value, Container) and not isinstance(value, ListConfig):
-            vkey, vval = get_dict_key_value_types(value._metadata.ref_type)
-            if vkey is not Any or vval is not Any:
+        def narrow_by_metadata(candidate_types: List[Any]) -> List[Any]:
+            meta_candidates: List[Any] = []
+            if (
+                isinstance(value, ListConfig)
+                and value._metadata.element_type is not Any
+            ):
+                meta_candidates = [
+                    t
+                    for t in candidate_types
+                    if is_list_annotation(t)
+                    and get_list_element_type(t) == value._metadata.element_type
+                ]
+            elif isinstance(value, TupleConfig):
+                value_type = normalize_tuple_annotation(value._metadata.ref_type)
+                value_item_types = get_tuple_item_types(value_type)
                 meta_candidates = [
-                    t for t in candidates if get_dict_key_value_types(t) == (vkey, vval)
+                    t
+                    for t in candidate_types
+                    if is_tuple_annotation(t)
+                    and get_tuple_item_types(normalize_tuple_annotation(t))
+                    == value_item_types
                 ]
-                if meta_candidates:
-                    candidates = meta_candidates
+            elif isinstance(value, Container) and not isinstance(
+                value, (ListConfig, TupleConfig)
+            ):
+                vkey, vval = get_dict_key_value_types(value._metadata.ref_type)
+                if vkey is not Any or vval is not Any:
+                    meta_candidates = [
+                        t
+                        for t in candidate_types
+                        if is_dict_annotation(t)
+                        and get_dict_key_value_types(t) == (vkey, vval)
+                    ]
+            return meta_candidates or candidate_types
+
+        def find_matches(candidate_types: List[Any]) -> List[Node]:
+            matches: List[Node] = []
+            for candidate_ref_type in narrow_by_metadata(candidate_types):
+                try:
+                    node = _node_wrap(
+                        value=value,
+                        ref_type=candidate_ref_type,
+                        is_optional=False,
+                        key=None,
+                        parent=self,
+                    )
+                    matches.append(node)
+                    if len(matches) > 1:
+                        break
+                except Exception:
+                    continue
+            return matches
 
-        matches: List[Node] = []
-        for candidate_ref_type in candidates:
-            try:
-                node = _node_wrap(
-                    value=value,
-                    ref_type=candidate_ref_type,
-                    is_optional=False,
-                    key=None,
-                    parent=self,
-                )
-                matches.append(node)
-                if len(matches) > 1:
-                    break  # ambiguous — stop constructing further candidates
-            except Exception:
-                continue
+        matches = find_matches(candidates)
+        if len(matches) == 0 and fallback_candidates:
+            matches = find_matches(fallback_candidates)
 
         if len(matches) == 0:
             raise ValidationError(

{omegaconf-2.4.0.dev12 → omegaconf-2.4.0.dev13}/omegaconf/basecontainer.py

@@ -131,6 +131,8 @@ class BaseContainer(Container, ABC):
                 dict_copy["_metadata"].ref_type = Dict
             elif is_list_annotation(ref_type):
                 dict_copy["_metadata"].ref_type = List
+            elif is_tuple_annotation(ref_type):
+                pass
             else:
                 assert False
         return dict_copy
@@ -164,6 +166,8 @@ class BaseContainer(Container, ABC):
                 ]
             elif is_generic_list(ref_type):
                 state_dict["_metadata"].ref_type = List[element_type]  # type: ignore
+            elif is_tuple_annotation(ref_type):
+                pass
             else:
                 assert False
 
@@ -253,8 +257,8 @@ class BaseContainer(Container, ABC):
         enum_to_str: bool = False,
         structured_config_mode: SCMode = SCMode.DICT,
         resolved_node_cache: Optional[Dict[int, Node]] = None,
-    ) -> Union[None, Any, str, Dict[DictKeyType, Any], List[Any]]:
-        from omegaconf import MISSING, DictConfig, ListConfig
+    ) -> Union[None, Any, str, Dict[DictKeyType, Any], List[Any], Tuple[Any, ...]]:
+        from omegaconf import MISSING, DictConfig, ListConfig, TupleConfig
 
         if resolve and resolved_node_cache is None:
             resolved_node_cache = {}
@@ -352,6 +356,8 @@ class BaseContainer(Container, ABC):
                 retlist.append(item)
 
             return retlist
+        elif isinstance(conf, TupleConfig):
+            return tuple(get_node_value(index) for index in range(len(conf)))
         assert False
 
     @staticmethod
@@ -362,7 +368,7 @@ class BaseContainer(Container, ABC):
         _allow_readonly_target: bool = False,
     ) -> None:
         """merge src into dest and return a new copy, does not modified input"""
-        from omegaconf import AnyNode, DictConfig, ValueNode
+        from omegaconf import AnyNode, DictConfig, ListConfig, TupleConfig, ValueNode
 
         assert isinstance(dest, DictConfig)
         assert isinstance(src, DictConfig)
@@ -440,13 +446,18 @@ class BaseContainer(Container, ABC):
 
             if (
                 isinstance(dest_node, Container)
+                and not isinstance(dest_node, TupleConfig)
                 and dest_node._is_none()
                 and not src_node_missing
                 and not _is_none(src_node, resolve=True)
             ):
                 expand(dest_node)
 
-            if dest_node is not None and dest_node._is_interpolation():
+            if (
+                dest_node is not None
+                and not isinstance(dest_node, TupleConfig)
+                and dest_node._is_interpolation()
+            ):
                 target_node = dest_node._maybe_dereference_node()
                 if isinstance(target_node, Container):
                     dest[key] = target_node
@@ -462,7 +473,11 @@ class BaseContainer(Container, ABC):
 
             if dest_node is not None:
                 if isinstance(dest_node, BaseContainer):
-                    if isinstance(src_node, BaseContainer):
+                    if isinstance(dest_node, TupleConfig) and isinstance(
+                        src_node, (ListConfig, TupleConfig)
+                    ):
+                        BaseContainer._tuple_merge(dest_node, src_node)
+                    elif isinstance(src_node, BaseContainer):
                         dest_node._merge_with(
                             src_node,
                             list_merge_mode=list_merge_mode,
@@ -562,6 +577,21 @@ class BaseContainer(Container, ABC):
             if value is not None:
                 dest._set_flag(flag, value)
 
+    @staticmethod
+    def _tuple_merge(dest: Any, src: Any) -> None:
+        from omegaconf import ListConfig, TupleConfig
+
+        assert isinstance(dest, TupleConfig)
+        assert isinstance(src, (ListConfig, TupleConfig))
+        if not src._is_missing():
+            dest._set_value(src)
+
+        flags = src._metadata.flags
+        assert flags is not None
+        for flag, value in flags.items():
+            if value is not None:
+                dest._set_flag(flag, value)
+
     def merge_with(
         self,
         *others: Union[
@@ -587,6 +617,7 @@ class BaseContainer(Container, ABC):
     ) -> None:
         from .dictconfig import DictConfig
         from .listconfig import ListConfig
+        from .tupleconfig import TupleConfig
 
         """merge a list of other Config objects into this one, overriding as needed"""
         for other in others:
@@ -615,14 +646,26 @@ class BaseContainer(Container, ABC):
                         list_merge_mode=list_merge_mode,
                         _allow_readonly_target=_allow_readonly_target,
                     )
-                elif isinstance(self, ListConfig) and isinstance(other, ListConfig):
+                elif isinstance(self, ListConfig) and isinstance(
+                    other, (ListConfig, TupleConfig)
+                ):
+                    if isinstance(other, TupleConfig):
+                        other = ListConfig(content=other)
                     BaseContainer._list_merge(
                         self,
                         other,
                         list_merge_mode=list_merge_mode,
                     )
+                elif isinstance(self, TupleConfig) and isinstance(
+                    other, (ListConfig, TupleConfig)
+                ):
+                    if not _allow_readonly_target:
+                        raise ConfigTypeError(
+                            "Cannot merge into a TupleConfig in-place"
+                        )
+                    BaseContainer._tuple_merge(self, other)
                 else:
-                    raise TypeError("Cannot merge DictConfig with ListConfig")
+                    raise TypeError("Cannot merge incompatible container types")
             finally:
                 if readonly_overridden:
                     self._set_flag("readonly", prev_readonly)
@@ -829,6 +872,9 @@ class BaseContainer(Container, ABC):
     def _get_full_key(self, key: Union[DictKeyType, int, slice, None]) -> str:
         from .listconfig import ListConfig
         from .omegaconf import _select_one
+        from .tupleconfig import TupleConfig
+
+        sequence_types = (ListConfig, TupleConfig)
 
         if not isinstance(key, (int, str, Enum, float, bool, slice, bytes, type(None))):
             return ""
@@ -857,9 +903,9 @@ class BaseContainer(Container, ABC):
 
             assert isinstance(key, str)
 
-            if issubclass(parent_type, ListConfig):
+            if issubclass(parent_type, sequence_types):
                 if full_key != "":
-                    if issubclass(cur_type, ListConfig):
+                    if issubclass(cur_type, sequence_types):
                         full_key = f"[{key}]{full_key}"
                     else:
                         full_key = f"[{key}].{full_key}"
@@ -869,7 +915,7 @@ class BaseContainer(Container, ABC):
                 if full_key == "":
                     full_key = key
                 else:
-                    if issubclass(cur_type, ListConfig):
+                    if issubclass(cur_type, sequence_types):
                         full_key = f"{key}{full_key}"
                     else:
                         full_key = f"{key}.{full_key}"
@@ -952,9 +998,14 @@ def _update_types(node: Node, ref_type: Any, object_type: Optional[type]) -> Non
 
 def _deep_update_type_hint(node: Node, type_hint: Any) -> None:
     """Ensure node is compatible with type_hint, mutating if necessary."""
-    from omegaconf import DictConfig, ListConfig, OmegaConf
+    from omegaconf import DictConfig, ListConfig, OmegaConf, TupleConfig
 
-    from ._utils import get_dict_key_value_types, get_list_element_type
+    from ._utils import (
+        get_dict_key_value_types,
+        get_list_element_type,
+        get_tuple_item_types,
+        is_variadic_tuple_annotation,
+    )
 
     if type_hint is Any:
         return
@@ -986,6 +1037,18 @@ def _deep_update_type_hint(node: Node, type_hint: Any) -> None:
             for i in range(len(node)):
                 _deep_update_subnode(node, i, new_element_type)
 
+    if is_tuple_annotation(new_ref_type) and isinstance(node, TupleConfig):
+        item_types = get_tuple_item_types(new_ref_type)
+        variadic = is_variadic_tuple_annotation(new_ref_type)
+        if not variadic and len(node) != len(item_types):
+            raise ValidationError(
+                f"TupleConfig length {len(node)} does not match type hint length {len(item_types)}"
+            )
+        if not _is_special(node):
+            for index in range(len(node)):
+                item_type = item_types[0] if variadic else item_types[index]
+                _deep_update_subnode(node, index, item_type)
+
     if is_dict_annotation(new_ref_type) and isinstance(node, DictConfig):
         new_key_type, new_element_type = get_dict_key_value_types(new_ref_type)
         node._metadata.key_type = new_key_type
@@ -1028,7 +1091,7 @@ def _deep_update_subnode(node: BaseContainer, key: Any, value_type_hint: Any) ->
 
 def _shallow_validate_type_hint(node: Node, type_hint: Any) -> None:
     """Error if node's type, content and metadata are not compatible with type_hint."""
-    from omegaconf import DictConfig, ListConfig, UnionNode, ValueNode
+    from omegaconf import DictConfig, ListConfig, TupleConfig, UnionNode, ValueNode
 
     is_optional, ref_type = _resolve_optional(type_hint)
 
@@ -1067,6 +1130,8 @@ def _shallow_validate_type_hint(node: Node, type_hint: Any) -> None:
             return
         elif is_list_annotation(ref_type) and isinstance(node, ListConfig):
             return
+        elif is_tuple_annotation(ref_type) and isinstance(node, TupleConfig):
+            return
         else:
             if isinstance(node, ValueNode):
                 value = node._value()

{omegaconf-2.4.0.dev12 → omegaconf-2.4.0.dev13}/omegaconf/listconfig.py

@@ -1,5 +1,6 @@
 import copy
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -13,6 +14,9 @@ from typing import (
     Union,
 )
 
+if TYPE_CHECKING:
+    from .tupleconfig import TupleConfig
+
 from ._utils import (
     ValueKind,
     _get_value,
@@ -44,7 +48,9 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
 
     def __init__(
         self,
-        content: Union[List[Any], Tuple[Any, ...], "ListConfig", str, None],
+        content: Union[
+            List[Any], Tuple[Any, ...], "ListConfig", "TupleConfig", str, None
+        ],
         key: Any = None,
         parent: Optional[Box] = None,
         element_type: Union[Type[Any], Any] = Any,
@@ -322,7 +328,13 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
             assert False
 
     def extend(self, lst: Iterable[Any]) -> None:
-        assert isinstance(lst, (tuple, list, ListConfig))
+        from omegaconf.tupleconfig import TupleConfig
+
+        if not isinstance(lst, (tuple, list, ListConfig, TupleConfig)):
+            raise TypeError(
+                "ListConfig.extend() expected a list, tuple, ListConfig, "
+                f"or TupleConfig, got {type(lst).__name__}"
+            )
         for x in lst:
             self.append(x)
 
@@ -604,6 +616,7 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
         self, value: Any, flags: Optional[Dict[str, bool]] = None
     ) -> None:
         from omegaconf import MISSING, flag_override
+        from omegaconf.tupleconfig import TupleConfig
 
         if flags is None:
             flags = {}
@@ -623,13 +636,18 @@ class ListConfig(BaseContainer, MutableSequence[Any]):
             self.__dict__["_content"] = value
             self._metadata.object_type = None
         else:
-            if not (is_primitive_list(value) or isinstance(value, ListConfig)):
+            if not (
+                is_primitive_list(value) or isinstance(value, (ListConfig, TupleConfig))
+            ):
                 type_ = type(value)
-                msg = f"Invalid value assigned: {type_.__name__} is not a ListConfig, list or tuple."
+                msg = (
+                    f"Invalid value assigned: {type_.__name__} is not a "
+                    "ListConfig, TupleConfig, list, or tuple."
+                )
                 raise ValidationError(msg)
 
             self.__dict__["_content"] = []
-            if isinstance(value, ListConfig):
+            if isinstance(value, (ListConfig, TupleConfig)):
                 self._metadata.flags = copy.deepcopy(flags)
                 # disable struct and readonly for the construction phase
                 # retaining other flags like allow_objects. The real flags are restored at the end of this function