Add files using upload-large-folder tool

.gitattributes

@@ -552,3 +552,4 @@ moondream/lib/python3.10/site-packages/pygments/lexers/__pycache__/lisp.cpython-
 parrot/lib/python3.10/site-packages/nvidia/cuda_cupti/lib/libcupti.so.12 filter=lfs diff=lfs merge=lfs -text
 moondream/lib/python3.10/site-packages/altair/vegalite/v5/__pycache__/api.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 mantis_evalkit/bin/python3.10 filter=lfs diff=lfs merge=lfs -text
+openflamingo/lib/python3.10/site-packages/torch/lib/libnvrtc-672ee683.so.11.2 filter=lfs diff=lfs merge=lfs -text

mantis_evalkit/lib/python3.10/site-packages/aiosignal/__init__.py

@@ -0,0 +1,36 @@
+from frozenlist import FrozenList
+
+__version__ = "1.3.2"
+
+__all__ = ("Signal",)
+
+
+class Signal(FrozenList):
+    """Coroutine-based signal implementation.
+
+    To connect a callback to a signal, use any list method.
+
+    Signals are fired using the send() coroutine, which takes named
+    arguments.
+    """
+
+    __slots__ = ("_owner",)
+
+    def __init__(self, owner):
+        super().__init__()
+        self._owner = owner
+
+    def __repr__(self):
+        return "<Signal owner={}, frozen={}, {!r}>".format(
+            self._owner, self.frozen, list(self)
+        )
+
+    async def send(self, *args, **kwargs):
+        """
+        Sends data to all registered receivers.
+        """
+        if not self.frozen:
+            raise RuntimeError("Cannot send non-frozen signal.")
+
+        for receiver in self:
+            await receiver(*args, **kwargs)  # type: ignore

mantis_evalkit/lib/python3.10/site-packages/aiosignal/__init__.pyi

@@ -0,0 +1,12 @@
+from typing import Any, Generic, TypeVar
+
+from frozenlist import FrozenList
+
+__all__ = ("Signal",)
+
+_T = TypeVar("_T")
+
+class Signal(FrozenList[_T], Generic[_T]):
+    def __init__(self, owner: Any) -> None: ...
+    def __repr__(self) -> str: ...
+    async def send(self, *args: Any, **kwargs: Any) -> None: ...

mantis_evalkit/lib/python3.10/site-packages/async_timeout/__init__.py

@@ -0,0 +1,276 @@
+import asyncio
+import enum
+import sys
+from types import TracebackType
+from typing import Optional, Type, final
+
+
+__version__ = "5.0.1"
+
+
+__all__ = ("timeout", "timeout_at", "Timeout")
+
+
+def timeout(delay: Optional[float]) -> "Timeout":
+    """timeout context manager.
+
+    Useful in cases when you want to apply timeout logic around block
+    of code or in cases when asyncio.wait_for is not suitable. For example:
+
+    >>> async with timeout(0.001):
+    ...     async with aiohttp.get('https://github.com') as r:
+    ...         await r.text()
+
+
+    delay - value in seconds or None to disable timeout logic
+    """
+    loop = asyncio.get_running_loop()
+    if delay is not None:
+        deadline = loop.time() + delay  # type: Optional[float]
+    else:
+        deadline = None
+    return Timeout(deadline, loop)
+
+
+def timeout_at(deadline: Optional[float]) -> "Timeout":
+    """Schedule the timeout at absolute time.
+
+    deadline argument points on the time in the same clock system
+    as loop.time().
+
+    Please note: it is not POSIX time but a time with
+    undefined starting base, e.g. the time of the system power on.
+
+    >>> async with timeout_at(loop.time() + 10):
+    ...     async with aiohttp.get('https://github.com') as r:
+    ...         await r.text()
+
+
+    """
+    loop = asyncio.get_running_loop()
+    return Timeout(deadline, loop)
+
+
+class _State(enum.Enum):
+    INIT = "INIT"
+    ENTER = "ENTER"
+    TIMEOUT = "TIMEOUT"
+    EXIT = "EXIT"
+
+
+if sys.version_info >= (3, 11):
+
+    class _Expired:
+        __slots__ = ("_val",)
+
+        def __init__(self, val: bool) -> None:
+            self._val = val
+
+        def __call__(self) -> bool:
+            return self._val
+
+        def __bool__(self) -> bool:
+            return self._val
+
+        def __repr__(self) -> str:
+            return repr(self._val)
+
+        def __str__(self) -> str:
+            return str(self._val)
+
+    @final
+    class Timeout(asyncio.Timeout):  # type: ignore[misc]
+        # Supports full asyncio.Timeout API.
+        # Also provides several asyncio_timeout specific methods
+        # for backward compatibility.
+        def __init__(
+            self, deadline: Optional[float], loop: asyncio.AbstractEventLoop
+        ) -> None:
+            super().__init__(deadline)
+
+        @property
+        def expired(self) -> _Expired:
+            # a hacky property hat can provide both roles:
+            # timeout.expired()  from asyncio
+            # timeout.expired    from asyncio_timeout
+            return _Expired(super().expired())
+
+        @property
+        def deadline(self) -> Optional[float]:
+            return self.when()
+
+        def reject(self) -> None:
+            """Reject scheduled timeout if any."""
+            # cancel is maybe better name but
+            # task.cancel() raises CancelledError in asyncio world.
+            self.reschedule(None)
+
+        def shift(self, delay: float) -> None:
+            """Advance timeout on delay seconds.
+
+            The delay can be negative.
+
+            Raise RuntimeError if shift is called when deadline is not scheduled
+            """
+            deadline = self.when()
+            if deadline is None:
+                raise RuntimeError("cannot shift timeout if deadline is not scheduled")
+            self.reschedule(deadline + delay)
+
+        def update(self, deadline: float) -> None:
+            """Set deadline to absolute value.
+
+            deadline argument points on the time in the same clock system
+            as loop.time().
+
+            If new deadline is in the past the timeout is raised immediately.
+
+            Please note: it is not POSIX time but a time with
+            undefined starting base, e.g. the time of the system power on.
+            """
+            self.reschedule(deadline)
+
+else:
+
+    @final
+    class Timeout:
+        # Internal class, please don't instantiate it directly
+        # Use timeout() and timeout_at() public factories instead.
+        #
+        # Implementation note: `async with timeout()` is preferred
+        # over `with timeout()`.
+        # While technically the Timeout class implementation
+        # doesn't need to be async at all,
+        # the `async with` statement explicitly points that
+        # the context manager should be used from async function context.
+        #
+        # This design allows to avoid many silly misusages.
+        #
+        # TimeoutError is raised immediately when scheduled
+        # if the deadline is passed.
+        # The purpose is to time out as soon as possible
+        # without waiting for the next await expression.
+
+        __slots__ = ("_deadline", "_loop", "_state", "_timeout_handler", "_task")
+
+        def __init__(
+            self, deadline: Optional[float], loop: asyncio.AbstractEventLoop
+        ) -> None:
+            self._loop = loop
+            self._state = _State.INIT
+
+            self._task: Optional["asyncio.Task[object]"] = None
+            self._timeout_handler = None  # type: Optional[asyncio.Handle]
+            if deadline is None:
+                self._deadline = None  # type: Optional[float]
+            else:
+                self.update(deadline)
+
+        async def __aenter__(self) -> "Timeout":
+            self._do_enter()
+            return self
+
+        async def __aexit__(
+            self,
+            exc_type: Optional[Type[BaseException]],
+            exc_val: Optional[BaseException],
+            exc_tb: Optional[TracebackType],
+        ) -> Optional[bool]:
+            self._do_exit(exc_type)
+            return None
+
+        @property
+        def expired(self) -> bool:
+            """Is timeout expired during execution?"""
+            return self._state == _State.TIMEOUT
+
+        @property
+        def deadline(self) -> Optional[float]:
+            return self._deadline
+
+        def reject(self) -> None:
+            """Reject scheduled timeout if any."""
+            # cancel is maybe better name but
+            # task.cancel() raises CancelledError in asyncio world.
+            if self._state not in (_State.INIT, _State.ENTER):
+                raise RuntimeError(f"invalid state {self._state.value}")
+            self._reject()
+
+        def _reject(self) -> None:
+            self._task = None
+            if self._timeout_handler is not None:
+                self._timeout_handler.cancel()
+                self._timeout_handler = None
+
+        def shift(self, delay: float) -> None:
+            """Advance timeout on delay seconds.
+
+            The delay can be negative.
+
+            Raise RuntimeError if shift is called when deadline is not scheduled
+            """
+            deadline = self._deadline
+            if deadline is None:
+                raise RuntimeError("cannot shift timeout if deadline is not scheduled")
+            self.update(deadline + delay)
+
+        def update(self, deadline: float) -> None:
+            """Set deadline to absolute value.
+
+            deadline argument points on the time in the same clock system
+            as loop.time().
+
+            If new deadline is in the past the timeout is raised immediately.
+
+            Please note: it is not POSIX time but a time with
+            undefined starting base, e.g. the time of the system power on.
+            """
+            if self._state == _State.EXIT:
+                raise RuntimeError("cannot reschedule after exit from context manager")
+            if self._state == _State.TIMEOUT:
+                raise RuntimeError("cannot reschedule expired timeout")
+            if self._timeout_handler is not None:
+                self._timeout_handler.cancel()
+            self._deadline = deadline
+            if self._state != _State.INIT:
+                self._reschedule()
+
+        def _reschedule(self) -> None:
+            assert self._state == _State.ENTER
+            deadline = self._deadline
+            if deadline is None:
+                return
+
+            now = self._loop.time()
+            if self._timeout_handler is not None:
+                self._timeout_handler.cancel()
+
+            self._task = asyncio.current_task()
+            if deadline <= now:
+                self._timeout_handler = self._loop.call_soon(self._on_timeout)
+            else:
+                self._timeout_handler = self._loop.call_at(deadline, self._on_timeout)
+
+        def _do_enter(self) -> None:
+            if self._state != _State.INIT:
+                raise RuntimeError(f"invalid state {self._state.value}")
+            self._state = _State.ENTER
+            self._reschedule()
+
+        def _do_exit(self, exc_type: Optional[Type[BaseException]]) -> None:
+            if exc_type is asyncio.CancelledError and self._state == _State.TIMEOUT:
+                assert self._task is not None
+                self._timeout_handler = None
+                self._task = None
+                raise asyncio.TimeoutError
+            # timeout has not expired
+            self._state = _State.EXIT
+            self._reject()
+            return None
+
+        def _on_timeout(self) -> None:
+            assert self._task is not None
+            self._task.cancel()
+            self._state = _State.TIMEOUT
+            # drop the reference early
+            self._timeout_handler = None

mantis_evalkit/lib/python3.10/site-packages/datasets/packaged_modules/folder_based_builder/folder_based_builder.py

@@ -0,0 +1,406 @@
+import collections
+import itertools
+import os
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Type
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.json as paj
+
+import datasets
+from datasets.features.features import FeatureType
+from datasets.tasks.base import TaskTemplate
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+def count_path_segments(path):
+    return path.replace("\\", "/").count("/")
+
+
+@dataclass
+class FolderBasedBuilderConfig(datasets.BuilderConfig):
+    """BuilderConfig for AutoFolder."""
+
+    features: Optional[datasets.Features] = None
+    drop_labels: bool = None
+    drop_metadata: bool = None
+
+
+class FolderBasedBuilder(datasets.GeneratorBasedBuilder):
+    """
+    Base class for generic data loaders for vision and image data.
+
+
+    Abstract class attributes to be overridden by a child class:
+        BASE_FEATURE: feature object to decode data (i.e. datasets.Image, datasets.Audio, ...)
+        BASE_COLUMN_NAME: string key name of a base feature (i.e. "image", "audio", ...)
+        BUILDER_CONFIG_CLASS: builder config inherited from `folder_based_builder.FolderBasedBuilderConfig`
+        EXTENSIONS: list of allowed extensions (only files with these extensions and METADATA_FILENAME files
+            will be included in a dataset)
+        CLASSIFICATION_TASK: classification task to use if labels are obtained from the folder structure
+    """
+
+    BASE_FEATURE: Type[FeatureType]
+    BASE_COLUMN_NAME: str
+    BUILDER_CONFIG_CLASS: FolderBasedBuilderConfig
+    EXTENSIONS: List[str]
+    CLASSIFICATION_TASK: TaskTemplate
+
+    METADATA_FILENAMES: List[str] = ["metadata.csv", "metadata.jsonl"]
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+
+        # Do an early pass if:
+        # * `drop_labels` is None (default) or False, to infer the class labels
+        # * `drop_metadata` is None (default) or False, to find the metadata files
+        do_analyze = not self.config.drop_labels or not self.config.drop_metadata
+        labels, path_depths = set(), set()
+        metadata_files = collections.defaultdict(set)
+
+        def analyze(files_or_archives, downloaded_files_or_dirs, split):
+            if len(downloaded_files_or_dirs) == 0:
+                return
+            # The files are separated from the archives at this point, so check the first sample
+            # to see if it's a file or a directory and iterate accordingly
+            if os.path.isfile(downloaded_files_or_dirs[0]):
+                original_files, downloaded_files = files_or_archives, downloaded_files_or_dirs
+                for original_file, downloaded_file in zip(original_files, downloaded_files):
+                    original_file, downloaded_file = str(original_file), str(downloaded_file)
+                    _, original_file_ext = os.path.splitext(original_file)
+                    if original_file_ext.lower() in self.EXTENSIONS:
+                        if not self.config.drop_labels:
+                            labels.add(os.path.basename(os.path.dirname(original_file)))
+                            path_depths.add(count_path_segments(original_file))
+                    elif os.path.basename(original_file) in self.METADATA_FILENAMES:
+                        metadata_files[split].add((original_file, downloaded_file))
+                    else:
+                        original_file_name = os.path.basename(original_file)
+                        logger.debug(
+                            f"The file '{original_file_name}' was ignored: it is not an image, and is not {self.METADATA_FILENAMES} either."
+                        )
+            else:
+                archives, downloaded_dirs = files_or_archives, downloaded_files_or_dirs
+                for archive, downloaded_dir in zip(archives, downloaded_dirs):
+                    archive, downloaded_dir = str(archive), str(downloaded_dir)
+                    for downloaded_dir_file in dl_manager.iter_files(downloaded_dir):
+                        _, downloaded_dir_file_ext = os.path.splitext(downloaded_dir_file)
+                        if downloaded_dir_file_ext in self.EXTENSIONS:
+                            if not self.config.drop_labels:
+                                labels.add(os.path.basename(os.path.dirname(downloaded_dir_file)))
+                                path_depths.add(count_path_segments(downloaded_dir_file))
+                        elif os.path.basename(downloaded_dir_file) in self.METADATA_FILENAMES:
+                            metadata_files[split].add((None, downloaded_dir_file))
+                        else:
+                            archive_file_name = os.path.basename(archive)
+                            original_file_name = os.path.basename(downloaded_dir_file)
+                            logger.debug(
+                                f"The file '{original_file_name}' from the archive '{archive_file_name}' was ignored: it is not an {self.BASE_COLUMN_NAME}, and is not {self.METADATA_FILENAMES} either."
+                            )
+
+        data_files = self.config.data_files
+        splits = []
+        for split_name, files in data_files.items():
+            if isinstance(files, str):
+                files = [files]
+            files, archives = self._split_files_and_archives(files)
+            downloaded_files = dl_manager.download(files)
+            downloaded_dirs = dl_manager.download_and_extract(archives)
+            if do_analyze:  # drop_metadata is None or False, drop_labels is None or False
+                logger.info(f"Searching for labels and/or metadata files in {split_name} data files...")
+                analyze(files, downloaded_files, split_name)
+                analyze(archives, downloaded_dirs, split_name)
+
+                if metadata_files:
+                    # add metadata if `metadata_files` are found and `drop_metadata` is None (default) or False
+                    add_metadata = not self.config.drop_metadata
+                    # if `metadata_files` are found, add labels only if
+                    # `drop_labels` is set up to False explicitly (not-default behavior)
+                    add_labels = self.config.drop_labels is False
+                else:
+                    # if `metadata_files` are not found, don't add metadata
+                    add_metadata = False
+                    # if `metadata_files` are not found and `drop_labels` is None (default) -
+                    # add labels if files are on the same level in directory hierarchy and there is more than one label
+                    add_labels = (
+                        (len(labels) > 1 and len(path_depths) == 1)
+                        if self.config.drop_labels is None
+                        else not self.config.drop_labels
+                    )
+
+                if add_labels:
+                    logger.info("Adding the labels inferred from data directories to the dataset's features...")
+                if add_metadata:
+                    logger.info("Adding metadata to the dataset...")
+            else:
+                add_labels, add_metadata, metadata_files = False, False, {}
+
+            splits.append(
+                datasets.SplitGenerator(
+                    name=split_name,
+                    gen_kwargs={
+                        "files": list(zip(files, downloaded_files))
+                        + [(None, dl_manager.iter_files(downloaded_dir)) for downloaded_dir in downloaded_dirs],
+                        "metadata_files": metadata_files,
+                        "split_name": split_name,
+                        "add_labels": add_labels,
+                        "add_metadata": add_metadata,
+                    },
+                )
+            )
+
+        if add_metadata:
+            # Verify that:
+            # * all metadata files have the same set of features
+            # * the `file_name` key is one of the metadata keys and is of type string
+            features_per_metadata_file: List[Tuple[str, datasets.Features]] = []
+
+            # Check that all metadata files share the same format
+            metadata_ext = {
+                os.path.splitext(original_metadata_file)[-1]
+                for original_metadata_file, _ in itertools.chain.from_iterable(metadata_files.values())
+            }
+            if len(metadata_ext) > 1:
+                raise ValueError(f"Found metadata files with different extensions: {list(metadata_ext)}")
+            metadata_ext = metadata_ext.pop()
+
+            for _, downloaded_metadata_file in itertools.chain.from_iterable(metadata_files.values()):
+                pa_metadata_table = self._read_metadata(downloaded_metadata_file, metadata_ext=metadata_ext)
+                features_per_metadata_file.append(
+                    (downloaded_metadata_file, datasets.Features.from_arrow_schema(pa_metadata_table.schema))
+                )
+            for downloaded_metadata_file, metadata_features in features_per_metadata_file:
+                if metadata_features != features_per_metadata_file[0][1]:
+                    raise ValueError(
+                        f"Metadata files {downloaded_metadata_file} and {features_per_metadata_file[0][0]} have different features: {features_per_metadata_file[0]} != {metadata_features}"
+                    )
+            metadata_features = features_per_metadata_file[0][1]
+            if "file_name" not in metadata_features:
+                raise ValueError("`file_name` must be present as dictionary key in metadata files")
+            if metadata_features["file_name"] != datasets.Value("string"):
+                raise ValueError("`file_name` key must be a string")
+            del metadata_features["file_name"]
+        else:
+            metadata_features = None
+
+        # Normally, we would do this in _info, but we need to know the labels and/or metadata
+        # before building the features
+        if self.config.features is None:
+            if add_labels:
+                self.info.features = datasets.Features(
+                    {
+                        self.BASE_COLUMN_NAME: self.BASE_FEATURE(),
+                        "label": datasets.ClassLabel(names=sorted(labels)),
+                    }
+                )
+                self.info.task_templates = [self.CLASSIFICATION_TASK.align_with_features(self.info.features)]
+            else:
+                self.info.features = datasets.Features({self.BASE_COLUMN_NAME: self.BASE_FEATURE()})
+
+            if add_metadata:
+                # Warn if there are duplicated keys in metadata compared to the existing features
+                # (`BASE_COLUMN_NAME`, optionally "label")
+                duplicated_keys = set(self.info.features) & set(metadata_features)
+                if duplicated_keys:
+                    logger.warning(
+                        f"Ignoring metadata columns {list(duplicated_keys)} as they are already present in "
+                        f"the features dictionary."
+                    )
+                # skip metadata duplicated keys
+                self.info.features.update(
+                    {
+                        feature: metadata_features[feature]
+                        for feature in metadata_features
+                        if feature not in duplicated_keys
+                    }
+                )
+
+        return splits
+
+    def _split_files_and_archives(self, data_files):
+        files, archives = [], []
+        for data_file in data_files:
+            _, data_file_ext = os.path.splitext(data_file)
+            if data_file_ext.lower() in self.EXTENSIONS:
+                files.append(data_file)
+            elif os.path.basename(data_file) in self.METADATA_FILENAMES:
+                files.append(data_file)
+            else:
+                archives.append(data_file)
+        return files, archives
+
+    def _read_metadata(self, metadata_file, metadata_ext: str = ""):
+        if metadata_ext == ".csv":
+            # Use `pd.read_csv` (although slower) instead of `pyarrow.csv.read_csv` for reading CSV files for consistency with the CSV packaged module
+            return pa.Table.from_pandas(pd.read_csv(metadata_file))
+        else:
+            with open(metadata_file, "rb") as f:
+                return paj.read_json(f)
+
+    def _generate_examples(self, files, metadata_files, split_name, add_metadata, add_labels):
+        split_metadata_files = metadata_files.get(split_name, [])
+        sample_empty_metadata = (
+            {k: None for k in self.info.features if k != self.BASE_COLUMN_NAME} if self.info.features else {}
+        )
+        last_checked_dir = None
+        metadata_dir = None
+        metadata_dict = None
+        downloaded_metadata_file = None
+
+        metadata_ext = ""
+        if split_metadata_files:
+            metadata_ext = {
+                os.path.splitext(original_metadata_file)[-1] for original_metadata_file, _ in split_metadata_files
+            }
+            metadata_ext = metadata_ext.pop()
+
+        file_idx = 0
+        for original_file, downloaded_file_or_dir in files:
+            if original_file is not None:
+                _, original_file_ext = os.path.splitext(original_file)
+                if original_file_ext.lower() in self.EXTENSIONS:
+                    if add_metadata:
+                        # If the file is a file of a needed type, and we've just entered a new directory,
+                        # find the nereast metadata file (by counting path segments) for the directory
+                        current_dir = os.path.dirname(original_file)
+                        if last_checked_dir is None or last_checked_dir != current_dir:
+                            last_checked_dir = current_dir
+                            metadata_file_candidates = [
+                                (
+                                    os.path.relpath(original_file, os.path.dirname(metadata_file_candidate)),
+                                    metadata_file_candidate,
+                                    downloaded_metadata_file,
+                                )
+                                for metadata_file_candidate, downloaded_metadata_file in split_metadata_files
+                                if metadata_file_candidate
+                                is not None  # ignore metadata_files that are inside archives
+                                and not os.path.relpath(
+                                    original_file, os.path.dirname(metadata_file_candidate)
+                                ).startswith("..")
+                            ]
+                            if metadata_file_candidates:
+                                _, metadata_file, downloaded_metadata_file = min(
+                                    metadata_file_candidates, key=lambda x: count_path_segments(x[0])
+                                )
+                                pa_metadata_table = self._read_metadata(
+                                    downloaded_metadata_file, metadata_ext=metadata_ext
+                                )
+                                pa_file_name_array = pa_metadata_table["file_name"]
+                                pa_metadata_table = pa_metadata_table.drop(["file_name"])
+                                metadata_dir = os.path.dirname(metadata_file)
+                                metadata_dict = {
+                                    os.path.normpath(file_name).replace("\\", "/"): sample_metadata
+                                    for file_name, sample_metadata in zip(
+                                        pa_file_name_array.to_pylist(), pa_metadata_table.to_pylist()
+                                    )
+                                }
+                            else:
+                                raise ValueError(
+                                    f"One or several metadata{metadata_ext} were found, but not in the same directory or in a parent directory of {downloaded_file_or_dir}."
+                                )
+                        if metadata_dir is not None and downloaded_metadata_file is not None:
+                            file_relpath = os.path.relpath(original_file, metadata_dir)
+                            file_relpath = file_relpath.replace("\\", "/")
+                            if file_relpath not in metadata_dict:
+                                raise ValueError(
+                                    f"{self.BASE_COLUMN_NAME} at {file_relpath} doesn't have metadata in {downloaded_metadata_file}."
+                                )
+                            sample_metadata = metadata_dict[file_relpath]
+                        else:
+                            raise ValueError(
+                                f"One or several metadata{metadata_ext} were found, but not in the same directory or in a parent directory of {downloaded_file_or_dir}."
+                            )
+                    else:
+                        sample_metadata = {}
+                    if add_labels:
+                        sample_label = {"label": os.path.basename(os.path.dirname(original_file))}
+                    else:
+                        sample_label = {}
+                    yield (
+                        file_idx,
+                        {
+                            **sample_empty_metadata,
+                            self.BASE_COLUMN_NAME: downloaded_file_or_dir,
+                            **sample_metadata,
+                            **sample_label,
+                        },
+                    )
+                    file_idx += 1
+            else:
+                for downloaded_dir_file in downloaded_file_or_dir:
+                    _, downloaded_dir_file_ext = os.path.splitext(downloaded_dir_file)
+                    if downloaded_dir_file_ext.lower() in self.EXTENSIONS:
+                        if add_metadata:
+                            current_dir = os.path.dirname(downloaded_dir_file)
+                            if last_checked_dir is None or last_checked_dir != current_dir:
+                                last_checked_dir = current_dir
+                                metadata_file_candidates = [
+                                    (
+                                        os.path.relpath(
+                                            downloaded_dir_file, os.path.dirname(downloaded_metadata_file)
+                                        ),
+                                        metadata_file_candidate,
+                                        downloaded_metadata_file,
+                                    )
+                                    for metadata_file_candidate, downloaded_metadata_file in split_metadata_files
+                                    if metadata_file_candidate
+                                    is None  # ignore metadata_files that are not inside archives
+                                    and not os.path.relpath(
+                                        downloaded_dir_file, os.path.dirname(downloaded_metadata_file)
+                                    ).startswith("..")
+                                ]
+                                if metadata_file_candidates:
+                                    _, metadata_file, downloaded_metadata_file = min(
+                                        metadata_file_candidates, key=lambda x: count_path_segments(x[0])
+                                    )
+                                    pa_metadata_table = self._read_metadata(
+                                        downloaded_metadata_file, metadata_ext=metadata_ext
+                                    )
+                                    pa_file_name_array = pa_metadata_table["file_name"]
+                                    pa_metadata_table = pa_metadata_table.drop(["file_name"])
+                                    metadata_dir = os.path.dirname(downloaded_metadata_file)
+                                    metadata_dict = {
+                                        os.path.normpath(file_name).replace("\\", "/"): sample_metadata
+                                        for file_name, sample_metadata in zip(
+                                            pa_file_name_array.to_pylist(), pa_metadata_table.to_pylist()
+                                        )
+                                    }
+                                else:
+                                    raise ValueError(
+                                        f"One or several metadata{metadata_ext} were found, but not in the same directory or in a parent directory of {downloaded_dir_file}."
+                                    )
+                            if metadata_dir is not None and downloaded_metadata_file is not None:
+                                downloaded_dir_file_relpath = os.path.relpath(downloaded_dir_file, metadata_dir)
+                                downloaded_dir_file_relpath = downloaded_dir_file_relpath.replace("\\", "/")
+                                if downloaded_dir_file_relpath not in metadata_dict:
+                                    raise ValueError(
+                                        f"{self.BASE_COLUMN_NAME} at {downloaded_dir_file_relpath} doesn't have metadata in {downloaded_metadata_file}."
+                                    )
+                                sample_metadata = metadata_dict[downloaded_dir_file_relpath]
+                            else:
+                                raise ValueError(
+                                    f"One or several metadata{metadata_ext} were found, but not in the same directory or in a parent directory of {downloaded_dir_file}."
+                                )
+                        else:
+                            sample_metadata = {}
+                        if add_labels:
+                            sample_label = {"label": os.path.basename(os.path.dirname(downloaded_dir_file))}
+                        else:
+                            sample_label = {}
+                        yield (
+                            file_idx,
+                            {
+                                **sample_empty_metadata,
+                                self.BASE_COLUMN_NAME: downloaded_dir_file,
+                                **sample_metadata,
+                                **sample_label,
+                            },
+                        )
+                        file_idx += 1

mantis_evalkit/lib/python3.10/site-packages/datasets/packaged_modules/sql/sql.py

@@ -0,0 +1,118 @@
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+
+import pandas as pd
+import pyarrow as pa
+
+import datasets
+import datasets.config
+from datasets.features.features import require_storage_cast
+from datasets.table import table_cast
+
+
+if TYPE_CHECKING:
+    import sqlite3
+
+    import sqlalchemy
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+@dataclass
+class SqlConfig(datasets.BuilderConfig):
+    """BuilderConfig for SQL."""
+
+    sql: Union[str, "sqlalchemy.sql.Selectable"] = None
+    con: Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"] = None
+    index_col: Optional[Union[str, List[str]]] = None
+    coerce_float: bool = True
+    params: Optional[Union[List, Tuple, Dict]] = None
+    parse_dates: Optional[Union[List, Dict]] = None
+    columns: Optional[List[str]] = None
+    chunksize: Optional[int] = 10_000
+    features: Optional[datasets.Features] = None
+
+    def __post_init__(self):
+        if self.sql is None:
+            raise ValueError("sql must be specified")
+        if self.con is None:
+            raise ValueError("con must be specified")
+
+    def create_config_id(
+        self,
+        config_kwargs: dict,
+        custom_features: Optional[datasets.Features] = None,
+    ) -> str:
+        config_kwargs = config_kwargs.copy()
+        # We need to stringify the Selectable object to make its hash deterministic
+
+        # The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
+        sql = config_kwargs["sql"]
+        if not isinstance(sql, str):
+            if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
+                import sqlalchemy
+
+                if isinstance(sql, sqlalchemy.sql.Selectable):
+                    engine = sqlalchemy.create_engine(config_kwargs["con"].split("://")[0] + "://")
+                    sql_str = str(sql.compile(dialect=engine.dialect))
+                    config_kwargs["sql"] = sql_str
+                else:
+                    raise TypeError(
+                        f"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(sql)}: {sql}"
+                    )
+            else:
+                raise TypeError(
+                    f"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(sql)}: {sql}"
+                )
+        con = config_kwargs["con"]
+        if not isinstance(con, str):
+            config_kwargs["con"] = id(con)
+            logger.info(
+                f"SQL connection 'con' of type {type(con)} couldn't be hashed properly. To enable hashing, specify 'con' as URI string instead."
+            )
+
+        return super().create_config_id(config_kwargs, custom_features=custom_features)
+
+    @property
+    def pd_read_sql_kwargs(self):
+        pd_read_sql_kwargs = {
+            "index_col": self.index_col,
+            "columns": self.columns,
+            "params": self.params,
+            "coerce_float": self.coerce_float,
+            "parse_dates": self.parse_dates,
+        }
+        return pd_read_sql_kwargs
+
+
+class Sql(datasets.ArrowBasedBuilder):
+    BUILDER_CONFIG_CLASS = SqlConfig
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={})]
+
+    def _cast_table(self, pa_table: pa.Table) -> pa.Table:
+        if self.config.features is not None:
+            schema = self.config.features.arrow_schema
+            if all(not require_storage_cast(feature) for feature in self.config.features.values()):
+                # cheaper cast
+                pa_table = pa.Table.from_arrays([pa_table[field.name] for field in schema], schema=schema)
+            else:
+                # more expensive cast; allows str <-> int/float or str to Audio for example
+                pa_table = table_cast(pa_table, schema)
+        return pa_table
+
+    def _generate_tables(self):
+        chunksize = self.config.chunksize
+        sql_reader = pd.read_sql(
+            self.config.sql, self.config.con, chunksize=chunksize, **self.config.pd_read_sql_kwargs
+        )
+        sql_reader = [sql_reader] if chunksize is None else sql_reader
+        for chunk_idx, df in enumerate(sql_reader):
+            pa_table = pa.Table.from_pandas(df)
+            yield chunk_idx, self._cast_table(pa_table)

mantis_evalkit/lib/python3.10/site-packages/datasets/packaged_modules/webdataset/_tenbin.py

@@ -0,0 +1,285 @@
+#
+# Copyright (c) 2017-2021 NVIDIA CORPORATION. All rights reserved.
+# This file coems from the WebDataset library.
+# See the LICENSE file for licensing terms (BSD-style).
+#
+
+"""
+Binary tensor encodings for PyTorch and NumPy.
+
+This defines efficient binary encodings for tensors. The format is 8 byte
+aligned and can be used directly for computations when transmitted, say,
+via RDMA. The format is supported by WebDataset with the `.ten` filename
+extension. It is also used by Tensorcom, Tensorcom RDMA, and can be used
+for fast tensor storage with LMDB and in disk files (which can be memory
+mapped)
+
+Data is encoded as a series of chunks:
+
+- magic number (int64)
+- length in bytes (int64)
+- bytes (multiple of 64 bytes long)
+
+Arrays are a header chunk followed by a data chunk.
+Header chunks have the following structure:
+
+- dtype (int64)
+- 8 byte array name
+- ndim (int64)
+- dim[0]
+- dim[1]
+- ...
+"""
+
+import struct
+import sys
+
+import numpy as np
+
+
+def bytelen(a):
+    """Determine the length of a in bytes."""
+    if hasattr(a, "nbytes"):
+        return a.nbytes
+    elif isinstance(a, (bytearray, bytes)):
+        return len(a)
+    else:
+        raise ValueError(a, "cannot determine nbytes")
+
+
+def bytedata(a):
+    """Return a the raw data corresponding to a."""
+    if isinstance(a, (bytearray, bytes, memoryview)):
+        return a
+    elif hasattr(a, "data"):
+        return a.data
+    else:
+        raise ValueError(a, "cannot return bytedata")
+
+
+# tables for converting between long/short NumPy dtypes
+
+long_to_short = """
+float16 f2
+float32 f4
+float64 f8
+int8 i1
+int16 i2
+int32 i4
+int64 i8
+uint8 u1
+uint16 u2
+unit32 u4
+uint64 u8
+""".strip()
+long_to_short = [x.split() for x in long_to_short.split("\n")]
+long_to_short = {x[0]: x[1] for x in long_to_short}
+short_to_long = {v: k for k, v in long_to_short.items()}
+
+
+def check_acceptable_input_type(data, allow64):
+    """Check that the data has an acceptable type for tensor encoding.
+
+    :param data: array
+    :param allow64: allow 64 bit types
+    """
+    for a in data:
+        if a.dtype.name not in long_to_short:
+            raise ValueError("unsupported dataypte")
+        if not allow64 and a.dtype.name not in ["float64", "int64", "uint64"]:
+            raise ValueError("64 bit datatypes not allowed unless explicitly enabled")
+
+
+def str64(s):
+    """Convert a string to an int64."""
+    s = s + "\0" * (8 - len(s))
+    s = s.encode("ascii")
+    return struct.unpack("@q", s)[0]
+
+
+def unstr64(i):
+    """Convert an int64 to a string."""
+    b = struct.pack("@q", i)
+    return b.decode("ascii").strip("\0")
+
+
+def check_infos(data, infos, required_infos=None):
+    """Verify the info strings."""
+    if required_infos is False or required_infos is None:
+        return data
+    if required_infos is True:
+        return data, infos
+    if not isinstance(required_infos, (tuple, list)):
+        raise ValueError("required_infos must be tuple or list")
+    for required, actual in zip(required_infos, infos):
+        raise ValueError(f"actual info {actual} doesn't match required info {required}")
+    return data
+
+
+def encode_header(a, info=""):
+    """Encode an array header as a byte array."""
+    if a.ndim >= 10:
+        raise ValueError("too many dimensions")
+    if a.nbytes != np.prod(a.shape) * a.itemsize:
+        raise ValueError("mismatch between size and shape")
+    if a.dtype.name not in long_to_short:
+        raise ValueError("unsupported array type")
+    header = [str64(long_to_short[a.dtype.name]), str64(info), len(a.shape)] + list(a.shape)
+    return bytedata(np.array(header, dtype="i8"))
+
+
+def decode_header(h):
+    """Decode a byte array into an array header."""
+    h = np.frombuffer(h, dtype="i8")
+    if unstr64(h[0]) not in short_to_long:
+        raise ValueError("unsupported array type")
+    dtype = np.dtype(short_to_long[unstr64(h[0])])
+    info = unstr64(h[1])
+    rank = int(h[2])
+    shape = tuple(h[3 : 3 + rank])
+    return shape, dtype, info
+
+
+def encode_list(l, infos=None):  # noqa: E741
+    """Given a list of arrays, encode them into a list of byte arrays."""
+    if infos is None:
+        infos = [""]
+    else:
+        if len(l) != len(infos):
+            raise ValueError(f"length of list {l} must muatch length of infos {infos}")
+    result = []
+    for i, a in enumerate(l):
+        header = encode_header(a, infos[i % len(infos)])
+        result += [header, bytedata(a)]
+    return result
+
+
+def decode_list(l, infos=False):  # noqa: E741
+    """Given a list of byte arrays, decode them into arrays."""
+    result = []
+    infos0 = []
+    for header, data in zip(l[::2], l[1::2]):
+        shape, dtype, info = decode_header(header)
+        a = np.frombuffer(data, dtype=dtype, count=np.prod(shape)).reshape(*shape)
+        result += [a]
+        infos0 += [info]
+    return check_infos(result, infos0, infos)
+
+
+magic_str = "~TenBin~"
+magic = str64(magic_str)
+magic_bytes = unstr64(magic).encode("ascii")
+
+
+def roundup(n, k=64):
+    """Round up to the next multiple of 64."""
+    return k * ((n + k - 1) // k)
+
+
+def encode_chunks(l):  # noqa: E741
+    """Encode a list of chunks into a single byte array, with lengths and magics.."""
+    size = sum(16 + roundup(b.nbytes) for b in l)
+    result = bytearray(size)
+    offset = 0
+    for b in l:
+        result[offset : offset + 8] = magic_bytes
+        offset += 8
+        result[offset : offset + 8] = struct.pack("@q", b.nbytes)
+        offset += 8
+        result[offset : offset + bytelen(b)] = b
+        offset += roundup(bytelen(b))
+    return result
+
+
+def decode_chunks(buf):
+    """Decode a byte array into a list of chunks."""
+    result = []
+    offset = 0
+    total = bytelen(buf)
+    while offset < total:
+        if magic_bytes != buf[offset : offset + 8]:
+            raise ValueError("magic bytes mismatch")
+        offset += 8
+        nbytes = struct.unpack("@q", buf[offset : offset + 8])[0]
+        offset += 8
+        b = buf[offset : offset + nbytes]
+        offset += roundup(nbytes)
+        result.append(b)
+    return result
+
+
+def encode_buffer(l, infos=None):  # noqa: E741
+    """Encode a list of arrays into a single byte array."""
+    if not isinstance(l, list):
+        raise ValueError("requires list")
+    return encode_chunks(encode_list(l, infos=infos))
+
+
+def decode_buffer(buf, infos=False):
+    """Decode a byte array into a list of arrays."""
+    return decode_list(decode_chunks(buf), infos=infos)
+
+
+def write_chunk(stream, buf):
+    """Write a byte chunk to the stream with magics, length, and padding."""
+    nbytes = bytelen(buf)
+    stream.write(magic_bytes)
+    stream.write(struct.pack("@q", nbytes))
+    stream.write(bytedata(buf))
+    padding = roundup(nbytes) - nbytes
+    if padding > 0:
+        stream.write(b"\0" * padding)
+
+
+def read_chunk(stream):
+    """Read a byte chunk from a stream with magics, length, and padding."""
+    magic = stream.read(8)
+    if magic == b"":
+        return None
+    if magic != magic_bytes:
+        raise ValueError("magic number does not match")
+    nbytes = stream.read(8)
+    nbytes = struct.unpack("@q", nbytes)[0]
+    if nbytes < 0:
+        raise ValueError("negative nbytes")
+    data = stream.read(nbytes)
+    padding = roundup(nbytes) - nbytes
+    if padding > 0:
+        stream.read(padding)
+    return data
+
+
+def write(stream, l, infos=None):  # noqa: E741
+    """Write a list of arrays to a stream, with magics, length, and padding."""
+    for chunk in encode_list(l, infos=infos):
+        write_chunk(stream, chunk)
+
+
+def read(stream, n=sys.maxsize, infos=False):
+    """Read a list of arrays from a stream, with magics, length, and padding."""
+    chunks = []
+    for _ in range(n):
+        header = read_chunk(stream)
+        if header is None:
+            break
+        data = read_chunk(stream)
+        if data is None:
+            raise ValueError("premature EOF")
+        chunks += [header, data]
+    return decode_list(chunks, infos=infos)
+
+
+def save(fname, *args, infos=None, nocheck=False):
+    """Save a list of arrays to a file, with magics, length, and padding."""
+    if not nocheck and not fname.endswith(".ten"):
+        raise ValueError("file name should end in .ten")
+    with open(fname, "wb") as stream:
+        write(stream, args, infos=infos)
+
+
+def load(fname, infos=False, nocheck=False):
+    """Read a list of arrays from a file, with magics, length, and padding."""
+    if not nocheck and not fname.endswith(".ten"):
+        raise ValueError("file name should end in .ten")
+    with open(fname, "rb") as stream:
+        return read(stream, infos=infos)

mantis_evalkit/lib/python3.10/site-packages/datasets/packaged_modules/webdataset/webdataset.py

@@ -0,0 +1,299 @@
+import io
+import json
+from itertools import islice
+from typing import Any, Callable, Dict, List
+
+import numpy as np
+import pyarrow as pa
+
+import datasets
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+class WebDataset(datasets.GeneratorBasedBuilder):
+    DEFAULT_WRITER_BATCH_SIZE = 100
+    IMAGE_EXTENSIONS: List[str]  # definition at the bottom of the script
+    AUDIO_EXTENSIONS: List[str]  # definition at the bottom of the script
+    DECODERS: Dict[str, Callable[[Any], Any]]  # definition at the bottom of the script
+    NUM_EXAMPLES_FOR_FEATURES_INFERENCE = 5
+
+    @classmethod
+    def _get_pipeline_from_tar(cls, tar_path, tar_iterator):
+        current_example = {}
+        for filename, f in tar_iterator:
+            if "." in filename:
+                example_key, field_name = filename.split(".", 1)
+                if current_example and current_example["__key__"] != example_key:
+                    yield current_example
+                    current_example = {}
+                current_example["__key__"] = example_key
+                current_example["__url__"] = tar_path
+                current_example[field_name.lower()] = f.read()
+                if field_name in cls.DECODERS:
+                    current_example[field_name] = cls.DECODERS[field_name](current_example[field_name])
+        if current_example:
+            yield current_example
+
+    def _info(self) -> datasets.DatasetInfo:
+        return datasets.DatasetInfo()
+
+    def _split_generators(self, dl_manager):
+        """We handle string, list and dicts in datafiles"""
+        # Download the data files
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+        data_files = dl_manager.download(self.config.data_files)
+        if isinstance(data_files, (str, list, tuple)):
+            tar_paths = data_files
+            if isinstance(tar_paths, str):
+                tar_paths = [tar_paths]
+            tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths]
+            splits = [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators}
+                )
+            ]
+        else:
+            splits = []
+            for split_name, tar_paths in data_files.items():
+                if isinstance(tar_paths, str):
+                    tar_paths = [tar_paths]
+                tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths]
+                splits.append(
+                    datasets.SplitGenerator(
+                        name=split_name, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators}
+                    )
+                )
+        if not self.info.features:
+            # Get one example to get the feature types
+            pipeline = self._get_pipeline_from_tar(tar_paths[0], tar_iterators[0])
+            first_examples = list(islice(pipeline, self.NUM_EXAMPLES_FOR_FEATURES_INFERENCE))
+            if any(example.keys() != first_examples[0].keys() for example in first_examples):
+                raise ValueError(
+                    "The TAR archives of the dataset should be in WebDataset format, "
+                    "but the files in the archive don't share the same prefix or the same types."
+                )
+            pa_tables = [pa.Table.from_pylist([example]) for example in first_examples]
+            if datasets.config.PYARROW_VERSION.major < 14:
+                inferred_arrow_schema = pa.concat_tables(pa_tables, promote=True).schema
+            else:
+                inferred_arrow_schema = pa.concat_tables(pa_tables, promote_options="default").schema
+            features = datasets.Features.from_arrow_schema(inferred_arrow_schema)
+
+            # Set Image types
+            for field_name in first_examples[0]:
+                extension = field_name.rsplit(".", 1)[-1]
+                if extension in self.IMAGE_EXTENSIONS:
+                    features[field_name] = datasets.Image()
+            # Set Audio types
+            for field_name in first_examples[0]:
+                extension = field_name.rsplit(".", 1)[-1]
+                if extension in self.AUDIO_EXTENSIONS:
+                    features[field_name] = datasets.Audio()
+            self.info.features = features
+
+        return splits
+
+    def _generate_examples(self, tar_paths, tar_iterators):
+        image_field_names = [
+            field_name for field_name, feature in self.info.features.items() if isinstance(feature, datasets.Image)
+        ]
+        audio_field_names = [
+            field_name for field_name, feature in self.info.features.items() if isinstance(feature, datasets.Audio)
+        ]
+        for tar_idx, (tar_path, tar_iterator) in enumerate(zip(tar_paths, tar_iterators)):
+            for example_idx, example in enumerate(self._get_pipeline_from_tar(tar_path, tar_iterator)):
+                for field_name in image_field_names + audio_field_names:
+                    example[field_name] = {"path": example["__key__"] + "." + field_name, "bytes": example[field_name]}
+                yield f"{tar_idx}_{example_idx}", example
+
+
+# Obtained with:
+# ```
+# import PIL.Image
+# IMAGE_EXTENSIONS = []
+# PIL.Image.init()
+# for ext, format in PIL.Image.EXTENSION.items():
+#     if format in PIL.Image.OPEN:
+#         IMAGE_EXTENSIONS.append(ext[1:])
+# ```
+# We intentionally do not run this code on launch because:
+# (1) Pillow is an optional dependency, so importing Pillow in global namespace is not allowed
+# (2) To ensure the list of supported extensions is deterministic
+IMAGE_EXTENSIONS = [
+    "blp",
+    "bmp",
+    "dib",
+    "bufr",
+    "cur",
+    "pcx",
+    "dcx",
+    "dds",
+    "ps",
+    "eps",
+    "fit",
+    "fits",
+    "fli",
+    "flc",
+    "ftc",
+    "ftu",
+    "gbr",
+    "gif",
+    "grib",
+    "h5",
+    "hdf",
+    "png",
+    "apng",
+    "jp2",
+    "j2k",
+    "jpc",
+    "jpf",
+    "jpx",
+    "j2c",
+    "icns",
+    "ico",
+    "im",
+    "iim",
+    "tif",
+    "tiff",
+    "jfif",
+    "jpe",
+    "jpg",
+    "jpeg",
+    "mpg",
+    "mpeg",
+    "msp",
+    "pcd",
+    "pxr",
+    "pbm",
+    "pgm",
+    "ppm",
+    "pnm",
+    "psd",
+    "bw",
+    "rgb",
+    "rgba",
+    "sgi",
+    "ras",
+    "tga",
+    "icb",
+    "vda",
+    "vst",
+    "webp",
+    "wmf",
+    "emf",
+    "xbm",
+    "xpm",
+]
+WebDataset.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS
+
+
+# Obtained with:
+# ```
+# import soundfile as sf
+#
+# AUDIO_EXTENSIONS = [f".{format.lower()}" for format in sf.available_formats().keys()]
+#
+# # .mp3 is currently decoded via `torchaudio`, .opus decoding is supported if version of `libsndfile` >= 1.0.30:
+# AUDIO_EXTENSIONS.extend([".mp3", ".opus"])
+# ```
+# We intentionally do not run this code on launch because:
+# (1) Soundfile is an optional dependency, so importing it in global namespace is not allowed
+# (2) To ensure the list of supported extensions is deterministic
+AUDIO_EXTENSIONS = [
+    "aiff",
+    "au",
+    "avr",
+    "caf",
+    "flac",
+    "htk",
+    "svx",
+    "mat4",
+    "mat5",
+    "mpc2k",
+    "ogg",
+    "paf",
+    "pvf",
+    "raw",
+    "rf64",
+    "sd2",
+    "sds",
+    "ircam",
+    "voc",
+    "w64",
+    "wav",
+    "nist",
+    "wavex",
+    "wve",
+    "xi",
+    "mp3",
+    "opus",
+]
+WebDataset.AUDIO_EXTENSIONS = AUDIO_EXTENSIONS
+
+
+def text_loads(data: bytes):
+    return data.decode("utf-8")
+
+
+def tenbin_loads(data: bytes):
+    from . import _tenbin
+
+    return _tenbin.decode_buffer(data)
+
+
+def msgpack_loads(data: bytes):
+    import msgpack
+
+    return msgpack.unpackb(data)
+
+
+def npy_loads(data: bytes):
+    import numpy.lib.format
+
+    stream = io.BytesIO(data)
+    return numpy.lib.format.read_array(stream, allow_pickle=False)
+
+
+def npz_loads(data: bytes):
+    return np.load(io.BytesIO(data), allow_pickle=False)
+
+
+def cbor_loads(data: bytes):
+    import cbor
+
+    return cbor.loads(data)
+
+
+# Obtained by checking `decoders` in `webdataset.autodecode`
+# and removing unsafe extension decoders.
+# Removed Pickle decoders:
+# - "pyd": lambda data: pickle.loads(data)
+# - "pickle": lambda data: pickle.loads(data)
+# Removed Torch decoders:
+# - "pth": lambda data: torch_loads(data)
+# Modified NumPy decoders to fix CVE-2019-6446 (add allow_pickle=False):
+# - "npy": npy_loads,
+# - "npz": lambda data: np.load(io.BytesIO(data)),
+DECODERS = {
+    "txt": text_loads,
+    "text": text_loads,
+    "transcript": text_loads,
+    "cls": int,
+    "cls2": int,
+    "index": int,
+    "inx": int,
+    "id": int,
+    "json": json.loads,
+    "jsn": json.loads,
+    "ten": tenbin_loads,
+    "tb": tenbin_loads,
+    "mp": msgpack_loads,
+    "msg": msgpack_loads,
+    "npy": npy_loads,
+    "npz": npz_loads,
+    "cbor": cbor_loads,
+}
+WebDataset.DECODERS = DECODERS

mantis_evalkit/lib/python3.10/site-packages/numpy/__config__.pyi

@@ -0,0 +1,102 @@
+from enum import Enum
+from types import ModuleType
+from typing import Final, Literal as L, TypedDict, overload, type_check_only
+from typing_extensions import NotRequired
+
+_CompilerConfigDictValue = TypedDict(
+    "_CompilerConfigDictValue",
+    {
+        "name": str,
+        "linker": str,
+        "version": str,
+        "commands": str,
+        "args": str,
+        "linker args": str,
+    },
+)
+_CompilerConfigDict = TypedDict(
+    "_CompilerConfigDict",
+    {
+        "c": _CompilerConfigDictValue,
+        "cython": _CompilerConfigDictValue,
+        "c++": _CompilerConfigDictValue,
+    },
+)
+_MachineInformationDict = TypedDict(
+    "_MachineInformationDict",
+    {
+        "host":_MachineInformationDictValue,
+        "build": _MachineInformationDictValue,
+        "cross-compiled": NotRequired[L[True]],
+    },
+)
+
+@type_check_only
+class _MachineInformationDictValue(TypedDict):
+    cpu: str
+    family: str
+    endian: L["little", "big"]
+    system: str
+
+_BuildDependenciesDictValue = TypedDict(
+    "_BuildDependenciesDictValue",
+    {
+        "name": str,
+        "found": NotRequired[L[True]],
+        "version": str,
+        "include directory": str,
+        "lib directory": str,
+        "openblas configuration": str,
+        "pc file directory": str,
+    },
+)
+
+class _BuildDependenciesDict(TypedDict):
+    blas: _BuildDependenciesDictValue
+    lapack: _BuildDependenciesDictValue
+
+class _PythonInformationDict(TypedDict):
+    path: str
+    version: str
+
+_SIMDExtensionsDict = TypedDict(
+    "_SIMDExtensionsDict",
+    {
+        "baseline": list[str],
+        "found": list[str],
+        "not found": list[str],
+    },
+)
+
+_ConfigDict = TypedDict(
+    "_ConfigDict",
+    {
+        "Compilers": _CompilerConfigDict,
+        "Machine Information": _MachineInformationDict,
+        "Build Dependencies": _BuildDependenciesDict,
+        "Python Information": _PythonInformationDict,
+        "SIMD Extensions": _SIMDExtensionsDict,
+    },
+)
+
+###
+
+__all__ = ["show_config"]
+
+CONFIG: Final[_ConfigDict] = ...
+
+class DisplayModes(Enum):
+    stdout = "stdout"
+    dicts = "dicts"
+
+def _check_pyyaml() -> ModuleType: ...
+
+@overload
+def show(mode: L["stdout"] = "stdout") -> None: ...
+@overload
+def show(mode: L["dicts"]) -> _ConfigDict: ...
+
+@overload
+def show_config(mode: L["stdout"] = "stdout") -> None: ...
+@overload
+def show_config(mode: L["dicts"]) -> _ConfigDict: ...

mantis_evalkit/lib/python3.10/site-packages/numpy/__init__.cython-30.pxd

@@ -0,0 +1,1243 @@
+# NumPy static imports for Cython >= 3.0
+#
+# If any of the PyArray_* functions are called, import_array must be
+# called first.  This is done automatically by Cython 3.0+ if a call
+# is not detected inside of the module.
+#
+# Author: Dag Sverre Seljebotn
+#
+
+from cpython.ref cimport Py_INCREF
+from cpython.object cimport PyObject, PyTypeObject, PyObject_TypeCheck
+cimport libc.stdio as stdio
+
+
+cdef extern from *:
+    # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython.
+    # See https://github.com/cython/cython/issues/3573
+    """
+    /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */
+    """
+
+
+cdef extern from "numpy/arrayobject.h":
+    # It would be nice to use size_t and ssize_t, but ssize_t has special
+    # implicit conversion rules, so just use "long".
+    # Note: The actual type only matters for Cython promotion, so long
+    #       is closer than int, but could lead to incorrect promotion.
+    #       (Not to worrying, and always the status-quo.)
+    ctypedef signed long npy_intp
+    ctypedef unsigned long npy_uintp
+
+    ctypedef unsigned char      npy_bool
+
+    ctypedef signed char      npy_byte
+    ctypedef signed short     npy_short
+    ctypedef signed int       npy_int
+    ctypedef signed long      npy_long
+    ctypedef signed long long npy_longlong
+
+    ctypedef unsigned char      npy_ubyte
+    ctypedef unsigned short     npy_ushort
+    ctypedef unsigned int       npy_uint
+    ctypedef unsigned long      npy_ulong
+    ctypedef unsigned long long npy_ulonglong
+
+    ctypedef float        npy_float
+    ctypedef double       npy_double
+    ctypedef long double  npy_longdouble
+
+    ctypedef signed char        npy_int8
+    ctypedef signed short       npy_int16
+    ctypedef signed int         npy_int32
+    ctypedef signed long long   npy_int64
+    ctypedef signed long long   npy_int96
+    ctypedef signed long long   npy_int128
+
+    ctypedef unsigned char      npy_uint8
+    ctypedef unsigned short     npy_uint16
+    ctypedef unsigned int       npy_uint32
+    ctypedef unsigned long long npy_uint64
+    ctypedef unsigned long long npy_uint96
+    ctypedef unsigned long long npy_uint128
+
+    ctypedef float        npy_float32
+    ctypedef double       npy_float64
+    ctypedef long double  npy_float80
+    ctypedef long double  npy_float96
+    ctypedef long double  npy_float128
+
+    ctypedef struct npy_cfloat:
+        pass
+
+    ctypedef struct npy_cdouble:
+        pass
+
+    ctypedef struct npy_clongdouble:
+        pass
+
+    ctypedef struct npy_complex64:
+        pass
+
+    ctypedef struct npy_complex128:
+        pass
+
+    ctypedef struct npy_complex160:
+        pass
+
+    ctypedef struct npy_complex192:
+        pass
+
+    ctypedef struct npy_complex256:
+        pass
+
+    ctypedef struct PyArray_Dims:
+        npy_intp *ptr
+        int len
+
+
+    cdef enum NPY_TYPES:
+        NPY_BOOL
+        NPY_BYTE
+        NPY_UBYTE
+        NPY_SHORT
+        NPY_USHORT
+        NPY_INT
+        NPY_UINT
+        NPY_LONG
+        NPY_ULONG
+        NPY_LONGLONG
+        NPY_ULONGLONG
+        NPY_FLOAT
+        NPY_DOUBLE
+        NPY_LONGDOUBLE
+        NPY_CFLOAT
+        NPY_CDOUBLE
+        NPY_CLONGDOUBLE
+        NPY_OBJECT
+        NPY_STRING
+        NPY_UNICODE
+        NPY_VOID
+        NPY_DATETIME
+        NPY_TIMEDELTA
+        NPY_NTYPES_LEGACY
+        NPY_NOTYPE
+
+        NPY_INT8
+        NPY_INT16
+        NPY_INT32
+        NPY_INT64
+        NPY_INT128
+        NPY_INT256
+        NPY_UINT8
+        NPY_UINT16
+        NPY_UINT32
+        NPY_UINT64
+        NPY_UINT128
+        NPY_UINT256
+        NPY_FLOAT16
+        NPY_FLOAT32
+        NPY_FLOAT64
+        NPY_FLOAT80
+        NPY_FLOAT96
+        NPY_FLOAT128
+        NPY_FLOAT256
+        NPY_COMPLEX32
+        NPY_COMPLEX64
+        NPY_COMPLEX128
+        NPY_COMPLEX160
+        NPY_COMPLEX192
+        NPY_COMPLEX256
+        NPY_COMPLEX512
+
+        NPY_INTP
+        NPY_UINTP
+        NPY_DEFAULT_INT  # Not a compile time constant (normally)!
+
+    ctypedef enum NPY_ORDER:
+        NPY_ANYORDER
+        NPY_CORDER
+        NPY_FORTRANORDER
+        NPY_KEEPORDER
+
+    ctypedef enum NPY_CASTING:
+        NPY_NO_CASTING
+        NPY_EQUIV_CASTING
+        NPY_SAFE_CASTING
+        NPY_SAME_KIND_CASTING
+        NPY_UNSAFE_CASTING
+
+    ctypedef enum NPY_CLIPMODE:
+        NPY_CLIP
+        NPY_WRAP
+        NPY_RAISE
+
+    ctypedef enum NPY_SCALARKIND:
+        NPY_NOSCALAR,
+        NPY_BOOL_SCALAR,
+        NPY_INTPOS_SCALAR,
+        NPY_INTNEG_SCALAR,
+        NPY_FLOAT_SCALAR,
+        NPY_COMPLEX_SCALAR,
+        NPY_OBJECT_SCALAR
+
+    ctypedef enum NPY_SORTKIND:
+        NPY_QUICKSORT
+        NPY_HEAPSORT
+        NPY_MERGESORT
+
+    ctypedef enum NPY_SEARCHSIDE:
+        NPY_SEARCHLEFT
+        NPY_SEARCHRIGHT
+
+    enum:
+        # DEPRECATED since NumPy 1.7 ! Do not use in new code!
+        NPY_C_CONTIGUOUS
+        NPY_F_CONTIGUOUS
+        NPY_CONTIGUOUS
+        NPY_FORTRAN
+        NPY_OWNDATA
+        NPY_FORCECAST
+        NPY_ENSURECOPY
+        NPY_ENSUREARRAY
+        NPY_ELEMENTSTRIDES
+        NPY_ALIGNED
+        NPY_NOTSWAPPED
+        NPY_WRITEABLE
+        NPY_ARR_HAS_DESCR
+
+        NPY_BEHAVED
+        NPY_BEHAVED_NS
+        NPY_CARRAY
+        NPY_CARRAY_RO
+        NPY_FARRAY
+        NPY_FARRAY_RO
+        NPY_DEFAULT
+
+        NPY_IN_ARRAY
+        NPY_OUT_ARRAY
+        NPY_INOUT_ARRAY
+        NPY_IN_FARRAY
+        NPY_OUT_FARRAY
+        NPY_INOUT_FARRAY
+
+        NPY_UPDATE_ALL
+
+    enum:
+        # Added in NumPy 1.7 to replace the deprecated enums above.
+        NPY_ARRAY_C_CONTIGUOUS
+        NPY_ARRAY_F_CONTIGUOUS
+        NPY_ARRAY_OWNDATA
+        NPY_ARRAY_FORCECAST
+        NPY_ARRAY_ENSURECOPY
+        NPY_ARRAY_ENSUREARRAY
+        NPY_ARRAY_ELEMENTSTRIDES
+        NPY_ARRAY_ALIGNED
+        NPY_ARRAY_NOTSWAPPED
+        NPY_ARRAY_WRITEABLE
+        NPY_ARRAY_WRITEBACKIFCOPY
+
+        NPY_ARRAY_BEHAVED
+        NPY_ARRAY_BEHAVED_NS
+        NPY_ARRAY_CARRAY
+        NPY_ARRAY_CARRAY_RO
+        NPY_ARRAY_FARRAY
+        NPY_ARRAY_FARRAY_RO
+        NPY_ARRAY_DEFAULT
+
+        NPY_ARRAY_IN_ARRAY
+        NPY_ARRAY_OUT_ARRAY
+        NPY_ARRAY_INOUT_ARRAY
+        NPY_ARRAY_IN_FARRAY
+        NPY_ARRAY_OUT_FARRAY
+        NPY_ARRAY_INOUT_FARRAY
+
+        NPY_ARRAY_UPDATE_ALL
+
+    cdef enum:
+        NPY_MAXDIMS  # 64 on NumPy 2.x and 32 on NumPy 1.x
+        NPY_RAVEL_AXIS  # Used for functions like PyArray_Mean
+
+    ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *,  void *)
+
+    ctypedef struct PyArray_ArrayDescr:
+        # shape is a tuple, but Cython doesn't support "tuple shape"
+        # inside a non-PyObject declaration, so we have to declare it
+        # as just a PyObject*.
+        PyObject* shape
+
+    ctypedef struct PyArray_Descr:
+        pass
+
+    ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]:
+        # Use PyDataType_* macros when possible, however there are no macros
+        # for accessing some of the fields, so some are defined.
+        cdef PyTypeObject* typeobj
+        cdef char kind
+        cdef char type
+        # Numpy sometimes mutates this without warning (e.g. it'll
+        # sometimes change "|" to "<" in shared dtype objects on
+        # little-endian machines). If this matters to you, use
+        # PyArray_IsNativeByteOrder(dtype.byteorder) instead of
+        # directly accessing this field.
+        cdef char byteorder
+        cdef int type_num
+
+        @property
+        cdef inline npy_intp itemsize(self) noexcept nogil:
+            return PyDataType_ELSIZE(self)
+
+        @property
+        cdef inline npy_intp alignment(self) noexcept nogil:
+            return PyDataType_ALIGNMENT(self)
+
+        # Use fields/names with care as they may be NULL.  You must check
+        # for this using PyDataType_HASFIELDS.
+        @property
+        cdef inline object fields(self):
+            return <object>PyDataType_FIELDS(self)
+
+        @property
+        cdef inline tuple names(self):
+            return <tuple>PyDataType_NAMES(self)
+
+        # Use PyDataType_HASSUBARRAY to test whether this field is
+        # valid (the pointer can be NULL). Most users should access
+        # this field via the inline helper method PyDataType_SHAPE.
+        @property
+        cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil:
+            return PyDataType_SUBARRAY(self)
+
+        @property
+        cdef inline npy_uint64 flags(self) noexcept nogil:
+            """The data types flags."""
+            return PyDataType_FLAGS(self)
+
+
+    ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]:
+        # Use through macros
+        pass
+
+    ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]:
+
+        @property
+        cdef inline int numiter(self) noexcept nogil:
+            """The number of arrays that need to be broadcast to the same shape."""
+            return PyArray_MultiIter_NUMITER(self)
+
+        @property
+        cdef inline npy_intp size(self) noexcept nogil:
+            """The total broadcasted size."""
+            return PyArray_MultiIter_SIZE(self)
+
+        @property
+        cdef inline npy_intp index(self) noexcept nogil:
+            """The current (1-d) index into the broadcasted result."""
+            return PyArray_MultiIter_INDEX(self)
+
+        @property
+        cdef inline int nd(self) noexcept nogil:
+            """The number of dimensions in the broadcasted result."""
+            return PyArray_MultiIter_NDIM(self)
+
+        @property
+        cdef inline npy_intp* dimensions(self) noexcept nogil:
+            """The shape of the broadcasted result."""
+            return PyArray_MultiIter_DIMS(self)
+
+        @property
+        cdef inline void** iters(self) noexcept nogil:
+            """An array of iterator objects that holds the iterators for the arrays to be broadcast together.
+            On return, the iterators are adjusted for broadcasting."""
+            return PyArray_MultiIter_ITERS(self)
+
+
+    ctypedef struct PyArrayObject:
+        # For use in situations where ndarray can't replace PyArrayObject*,
+        # like PyArrayObject**.
+        pass
+
+    ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]:
+        cdef __cythonbufferdefaults__ = {"mode": "strided"}
+
+        # NOTE: no field declarations since direct access is deprecated since NumPy 1.7
+        # Instead, we use properties that map to the corresponding C-API functions.
+
+        @property
+        cdef inline PyObject* base(self) noexcept nogil:
+            """Returns a borrowed reference to the object owning the data/memory.
+            """
+            return PyArray_BASE(self)
+
+        @property
+        cdef inline dtype descr(self):
+            """Returns an owned reference to the dtype of the array.
+            """
+            return <dtype>PyArray_DESCR(self)
+
+        @property
+        cdef inline int ndim(self) noexcept nogil:
+            """Returns the number of dimensions in the array.
+            """
+            return PyArray_NDIM(self)
+
+        @property
+        cdef inline npy_intp *shape(self) noexcept nogil:
+            """Returns a pointer to the dimensions/shape of the array.
+            The number of elements matches the number of dimensions of the array (ndim).
+            Can return NULL for 0-dimensional arrays.
+            """
+            return PyArray_DIMS(self)
+
+        @property
+        cdef inline npy_intp *strides(self) noexcept nogil:
+            """Returns a pointer to the strides of the array.
+            The number of elements matches the number of dimensions of the array (ndim).
+            """
+            return PyArray_STRIDES(self)
+
+        @property
+        cdef inline npy_intp size(self) noexcept nogil:
+            """Returns the total size (in number of elements) of the array.
+            """
+            return PyArray_SIZE(self)
+
+        @property
+        cdef inline char* data(self) noexcept nogil:
+            """The pointer to the data buffer as a char*.
+            This is provided for legacy reasons to avoid direct struct field access.
+            For new code that needs this access, you probably want to cast the result
+            of `PyArray_DATA()` instead, which returns a 'void*'.
+            """
+            return PyArray_BYTES(self)
+
+
+    int _import_array() except -1
+    # A second definition so _import_array isn't marked as used when we use it here.
+    # Do not use - subject to change any time.
+    int __pyx_import_array "_import_array"() except -1
+
+    #
+    # Macros from ndarrayobject.h
+    #
+    bint PyArray_CHKFLAGS(ndarray m, int flags) nogil
+    bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil
+    bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil
+    bint PyArray_ISCONTIGUOUS(ndarray m) nogil
+    bint PyArray_ISWRITEABLE(ndarray m) nogil
+    bint PyArray_ISALIGNED(ndarray m) nogil
+
+    int PyArray_NDIM(ndarray) nogil
+    bint PyArray_ISONESEGMENT(ndarray) nogil
+    bint PyArray_ISFORTRAN(ndarray) nogil
+    int PyArray_FORTRANIF(ndarray) nogil
+
+    void* PyArray_DATA(ndarray) nogil
+    char* PyArray_BYTES(ndarray) nogil
+
+    npy_intp* PyArray_DIMS(ndarray) nogil
+    npy_intp* PyArray_STRIDES(ndarray) nogil
+    npy_intp PyArray_DIM(ndarray, size_t) nogil
+    npy_intp PyArray_STRIDE(ndarray, size_t) nogil
+
+    PyObject *PyArray_BASE(ndarray) nogil  # returns borrowed reference!
+    PyArray_Descr *PyArray_DESCR(ndarray) nogil  # returns borrowed reference to dtype!
+    PyArray_Descr *PyArray_DTYPE(ndarray) nogil  # returns borrowed reference to dtype! NP 1.7+ alias for descr.
+    int PyArray_FLAGS(ndarray) nogil
+    void PyArray_CLEARFLAGS(ndarray, int flags) nogil  # Added in NumPy 1.7
+    void PyArray_ENABLEFLAGS(ndarray, int flags) nogil  # Added in NumPy 1.7
+    npy_intp PyArray_ITEMSIZE(ndarray) nogil
+    int PyArray_TYPE(ndarray arr) nogil
+
+    object PyArray_GETITEM(ndarray arr, void *itemptr)
+    int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) except -1
+
+    bint PyTypeNum_ISBOOL(int) nogil
+    bint PyTypeNum_ISUNSIGNED(int) nogil
+    bint PyTypeNum_ISSIGNED(int) nogil
+    bint PyTypeNum_ISINTEGER(int) nogil
+    bint PyTypeNum_ISFLOAT(int) nogil
+    bint PyTypeNum_ISNUMBER(int) nogil
+    bint PyTypeNum_ISSTRING(int) nogil
+    bint PyTypeNum_ISCOMPLEX(int) nogil
+    bint PyTypeNum_ISFLEXIBLE(int) nogil
+    bint PyTypeNum_ISUSERDEF(int) nogil
+    bint PyTypeNum_ISEXTENDED(int) nogil
+    bint PyTypeNum_ISOBJECT(int) nogil
+
+    npy_intp PyDataType_ELSIZE(dtype) nogil
+    npy_intp PyDataType_ALIGNMENT(dtype) nogil
+    PyObject* PyDataType_METADATA(dtype) nogil
+    PyArray_ArrayDescr* PyDataType_SUBARRAY(dtype) nogil
+    PyObject* PyDataType_NAMES(dtype) nogil
+    PyObject* PyDataType_FIELDS(dtype) nogil
+
+    bint PyDataType_ISBOOL(dtype) nogil
+    bint PyDataType_ISUNSIGNED(dtype) nogil
+    bint PyDataType_ISSIGNED(dtype) nogil
+    bint PyDataType_ISINTEGER(dtype) nogil
+    bint PyDataType_ISFLOAT(dtype) nogil
+    bint PyDataType_ISNUMBER(dtype) nogil
+    bint PyDataType_ISSTRING(dtype) nogil
+    bint PyDataType_ISCOMPLEX(dtype) nogil
+    bint PyDataType_ISFLEXIBLE(dtype) nogil
+    bint PyDataType_ISUSERDEF(dtype) nogil
+    bint PyDataType_ISEXTENDED(dtype) nogil
+    bint PyDataType_ISOBJECT(dtype) nogil
+    bint PyDataType_HASFIELDS(dtype) nogil
+    bint PyDataType_HASSUBARRAY(dtype) nogil
+    npy_uint64 PyDataType_FLAGS(dtype) nogil
+
+    bint PyArray_ISBOOL(ndarray) nogil
+    bint PyArray_ISUNSIGNED(ndarray) nogil
+    bint PyArray_ISSIGNED(ndarray) nogil
+    bint PyArray_ISINTEGER(ndarray) nogil
+    bint PyArray_ISFLOAT(ndarray) nogil
+    bint PyArray_ISNUMBER(ndarray) nogil
+    bint PyArray_ISSTRING(ndarray) nogil
+    bint PyArray_ISCOMPLEX(ndarray) nogil
+    bint PyArray_ISFLEXIBLE(ndarray) nogil
+    bint PyArray_ISUSERDEF(ndarray) nogil
+    bint PyArray_ISEXTENDED(ndarray) nogil
+    bint PyArray_ISOBJECT(ndarray) nogil
+    bint PyArray_HASFIELDS(ndarray) nogil
+
+    bint PyArray_ISVARIABLE(ndarray) nogil
+
+    bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil
+    bint PyArray_ISNBO(char) nogil              # works on ndarray.byteorder
+    bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder
+    bint PyArray_ISNOTSWAPPED(ndarray) nogil
+    bint PyArray_ISBYTESWAPPED(ndarray) nogil
+
+    bint PyArray_FLAGSWAP(ndarray, int) nogil
+
+    bint PyArray_ISCARRAY(ndarray) nogil
+    bint PyArray_ISCARRAY_RO(ndarray) nogil
+    bint PyArray_ISFARRAY(ndarray) nogil
+    bint PyArray_ISFARRAY_RO(ndarray) nogil
+    bint PyArray_ISBEHAVED(ndarray) nogil
+    bint PyArray_ISBEHAVED_RO(ndarray) nogil
+
+
+    bint PyDataType_ISNOTSWAPPED(dtype) nogil
+    bint PyDataType_ISBYTESWAPPED(dtype) nogil
+
+    bint PyArray_DescrCheck(object)
+
+    bint PyArray_Check(object)
+    bint PyArray_CheckExact(object)
+
+    # Cannot be supported due to out arg:
+    # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&)
+    # bint PyArray_HasArrayInterface(op, out)
+
+
+    bint PyArray_IsZeroDim(object)
+    # Cannot be supported due to ## ## in macro:
+    # bint PyArray_IsScalar(object, verbatim work)
+    bint PyArray_CheckScalar(object)
+    bint PyArray_IsPythonNumber(object)
+    bint PyArray_IsPythonScalar(object)
+    bint PyArray_IsAnyScalar(object)
+    bint PyArray_CheckAnyScalar(object)
+
+    ndarray PyArray_GETCONTIGUOUS(ndarray)
+    bint PyArray_SAMESHAPE(ndarray, ndarray) nogil
+    npy_intp PyArray_SIZE(ndarray) nogil
+    npy_intp PyArray_NBYTES(ndarray) nogil
+
+    object PyArray_FROM_O(object)
+    object PyArray_FROM_OF(object m, int flags)
+    object PyArray_FROM_OT(object m, int type)
+    object PyArray_FROM_OTF(object m, int type, int flags)
+    object PyArray_FROMANY(object m, int type, int min, int max, int flags)
+    object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran)
+    object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran)
+    void PyArray_FILLWBYTE(ndarray, int val)
+    object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth)
+    unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2)
+    bint PyArray_EquivByteorders(int b1, int b2) nogil
+    object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum)
+    object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data)
+    #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr)
+    object PyArray_ToScalar(void* data, ndarray arr)
+
+    void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil
+    void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil
+    void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil
+    void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil
+
+    # Cannot be supported due to out arg
+    # void PyArray_DESCR_REPLACE(descr)
+
+
+    object PyArray_Copy(ndarray)
+    object PyArray_FromObject(object op, int type, int min_depth, int max_depth)
+    object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth)
+    object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth)
+
+    object PyArray_Cast(ndarray mp, int type_num)
+    object PyArray_Take(ndarray ap, object items, int axis)
+    object PyArray_Put(ndarray ap, object items, object values)
+
+    void PyArray_ITER_RESET(flatiter it) nogil
+    void PyArray_ITER_NEXT(flatiter it) nogil
+    void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil
+    void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil
+    void* PyArray_ITER_DATA(flatiter it) nogil
+    bint PyArray_ITER_NOTDONE(flatiter it) nogil
+
+    void PyArray_MultiIter_RESET(broadcast multi) nogil
+    void PyArray_MultiIter_NEXT(broadcast multi) nogil
+    void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil
+    void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil
+    void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil
+    void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil
+    bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil
+    npy_intp PyArray_MultiIter_SIZE(broadcast multi) nogil
+    int PyArray_MultiIter_NDIM(broadcast multi) nogil
+    npy_intp PyArray_MultiIter_INDEX(broadcast multi) nogil
+    int PyArray_MultiIter_NUMITER(broadcast multi) nogil
+    npy_intp* PyArray_MultiIter_DIMS(broadcast multi) nogil
+    void** PyArray_MultiIter_ITERS(broadcast multi) nogil
+
+    # Functions from __multiarray_api.h
+
+    # Functions taking dtype and returning object/ndarray are disabled
+    # for now as they steal dtype references. I'm conservative and disable
+    # more than is probably needed until it can be checked further.
+    int PyArray_INCREF (ndarray) except *  # uses PyArray_Item_INCREF...
+    int PyArray_XDECREF (ndarray) except *  # uses PyArray_Item_DECREF...
+    dtype PyArray_DescrFromType (int)
+    object PyArray_TypeObjectFromType (int)
+    char * PyArray_Zero (ndarray)
+    char * PyArray_One (ndarray)
+    #object PyArray_CastToType (ndarray, dtype, int)
+    int PyArray_CanCastSafely (int, int)  # writes errors
+    npy_bool PyArray_CanCastTo (dtype, dtype)  # writes errors
+    int PyArray_ObjectType (object, int) except 0
+    dtype PyArray_DescrFromObject (object, dtype)
+    #ndarray* PyArray_ConvertToCommonType (object, int *)
+    dtype PyArray_DescrFromScalar (object)
+    dtype PyArray_DescrFromTypeObject (object)
+    npy_intp PyArray_Size (object)
+    #object PyArray_Scalar (void *, dtype, object)
+    #object PyArray_FromScalar (object, dtype)
+    void PyArray_ScalarAsCtype (object, void *)
+    #int PyArray_CastScalarToCtype (object, void *, dtype)
+    #int PyArray_CastScalarDirect (object, dtype, void *, int)
+    #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int)
+    #object PyArray_FromAny (object, dtype, int, int, int, object)
+    object PyArray_EnsureArray (object)
+    object PyArray_EnsureAnyArray (object)
+    #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *)
+    #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *)
+    #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp)
+    #object PyArray_FromIter (object, dtype, npy_intp)
+    object PyArray_Return (ndarray)
+    #object PyArray_GetField (ndarray, dtype, int)
+    #int PyArray_SetField (ndarray, dtype, int, object) except -1
+    object PyArray_Byteswap (ndarray, npy_bool)
+    object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER)
+    int PyArray_CopyInto (ndarray, ndarray) except -1
+    int PyArray_CopyAnyInto (ndarray, ndarray) except -1
+    int PyArray_CopyObject (ndarray, object) except -1
+    object PyArray_NewCopy (ndarray, NPY_ORDER)
+    object PyArray_ToList (ndarray)
+    object PyArray_ToString (ndarray, NPY_ORDER)
+    int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) except -1
+    int PyArray_Dump (object, object, int) except -1
+    object PyArray_Dumps (object, int)
+    int PyArray_ValidType (int)  # Cannot error
+    void PyArray_UpdateFlags (ndarray, int)
+    object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object)
+    #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object)
+    #dtype PyArray_DescrNew (dtype)
+    dtype PyArray_DescrNewFromType (int)
+    double PyArray_GetPriority (object, double)  # clears errors as of 1.25
+    object PyArray_IterNew (object)
+    object PyArray_MultiIterNew (int, ...)
+
+    int PyArray_PyIntAsInt (object) except? -1
+    npy_intp PyArray_PyIntAsIntp (object)
+    int PyArray_Broadcast (broadcast) except -1
+    int PyArray_FillWithScalar (ndarray, object) except -1
+    npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *)
+    dtype PyArray_DescrNewByteorder (dtype, char)
+    object PyArray_IterAllButAxis (object, int *)
+    #object PyArray_CheckFromAny (object, dtype, int, int, int, object)
+    #object PyArray_FromArray (ndarray, dtype, int)
+    object PyArray_FromInterface (object)
+    object PyArray_FromStructInterface (object)
+    #object PyArray_FromArrayAttr (object, dtype, object)
+    #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*)
+    int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND)
+    npy_bool PyArray_CanCastScalar (type, type)
+    int PyArray_RemoveSmallest (broadcast) except -1
+    int PyArray_ElementStrides (object)
+    void PyArray_Item_INCREF (char *, dtype) except *
+    void PyArray_Item_XDECREF (char *, dtype) except *
+    object PyArray_Transpose (ndarray, PyArray_Dims *)
+    object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE)
+    object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE)
+    object PyArray_PutMask (ndarray, object, object)
+    object PyArray_Repeat (ndarray, object, int)
+    object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE)
+    int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1
+    object PyArray_ArgSort (ndarray, int, NPY_SORTKIND)
+    object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject *)
+    object PyArray_ArgMax (ndarray, int, ndarray)
+    object PyArray_ArgMin (ndarray, int, ndarray)
+    object PyArray_Reshape (ndarray, object)
+    object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER)
+    object PyArray_Squeeze (ndarray)
+    #object PyArray_View (ndarray, dtype, type)
+    object PyArray_SwapAxes (ndarray, int, int)
+    object PyArray_Max (ndarray, int, ndarray)
+    object PyArray_Min (ndarray, int, ndarray)
+    object PyArray_Ptp (ndarray, int, ndarray)
+    object PyArray_Mean (ndarray, int, int, ndarray)
+    object PyArray_Trace (ndarray, int, int, int, int, ndarray)
+    object PyArray_Diagonal (ndarray, int, int, int)
+    object PyArray_Clip (ndarray, object, object, ndarray)
+    object PyArray_Conjugate (ndarray, ndarray)
+    object PyArray_Nonzero (ndarray)
+    object PyArray_Std (ndarray, int, int, ndarray, int)
+    object PyArray_Sum (ndarray, int, int, ndarray)
+    object PyArray_CumSum (ndarray, int, int, ndarray)
+    object PyArray_Prod (ndarray, int, int, ndarray)
+    object PyArray_CumProd (ndarray, int, int, ndarray)
+    object PyArray_All (ndarray, int, ndarray)
+    object PyArray_Any (ndarray, int, ndarray)
+    object PyArray_Compress (ndarray, object, int, ndarray)
+    object PyArray_Flatten (ndarray, NPY_ORDER)
+    object PyArray_Ravel (ndarray, NPY_ORDER)
+    npy_intp PyArray_MultiplyList (npy_intp *, int)
+    int PyArray_MultiplyIntList (int *, int)
+    void * PyArray_GetPtr (ndarray, npy_intp*)
+    int PyArray_CompareLists (npy_intp *, npy_intp *, int)
+    #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype)
+    int PyArray_Free (object, void *)
+    #int PyArray_Converter (object, object*)
+    int PyArray_IntpFromSequence (object, npy_intp *, int) except -1
+    object PyArray_Concatenate (object, int)
+    object PyArray_InnerProduct (object, object)
+    object PyArray_MatrixProduct (object, object)
+    object PyArray_Correlate (object, object, int)
+    #int PyArray_DescrConverter (object, dtype*) except 0
+    #int PyArray_DescrConverter2 (object, dtype*) except 0
+    int PyArray_IntpConverter (object, PyArray_Dims *) except 0
+    #int PyArray_BufferConverter (object, chunk) except 0
+    int PyArray_AxisConverter (object, int *) except 0
+    int PyArray_BoolConverter (object, npy_bool *) except 0
+    int PyArray_ByteorderConverter (object, char *) except 0
+    int PyArray_OrderConverter (object, NPY_ORDER *) except 0
+    unsigned char PyArray_EquivTypes (dtype, dtype)  # clears errors
+    #object PyArray_Zeros (int, npy_intp *, dtype, int)
+    #object PyArray_Empty (int, npy_intp *, dtype, int)
+    object PyArray_Where (object, object, object)
+    object PyArray_Arange (double, double, double, int)
+    #object PyArray_ArangeObj (object, object, object, dtype)
+    int PyArray_SortkindConverter (object, NPY_SORTKIND *) except 0
+    object PyArray_LexSort (object, int)
+    object PyArray_Round (ndarray, int, ndarray)
+    unsigned char PyArray_EquivTypenums (int, int)
+    int PyArray_RegisterDataType (dtype) except -1
+    int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) except -1
+    int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1
+    #void PyArray_InitArrFuncs (PyArray_ArrFuncs *)
+    object PyArray_IntTupleFromIntp (int, npy_intp *)
+    int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) except 0
+    #int PyArray_OutputConverter (object, ndarray*) except 0
+    object PyArray_BroadcastToShape (object, npy_intp *, int)
+    #int PyArray_DescrAlignConverter (object, dtype*) except 0
+    #int PyArray_DescrAlignConverter2 (object, dtype*) except 0
+    int PyArray_SearchsideConverter (object, void *) except 0
+    object PyArray_CheckAxis (ndarray, int *, int)
+    npy_intp PyArray_OverflowMultiplyList (npy_intp *, int)
+    int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead.
+
+    # The memory handler functions require the NumPy 1.22 API
+    # and may require defining NPY_TARGET_VERSION
+    ctypedef struct PyDataMemAllocator:
+        void *ctx
+        void* (*malloc) (void *ctx, size_t size)
+        void* (*calloc) (void *ctx, size_t nelem, size_t elsize)
+        void* (*realloc) (void *ctx, void *ptr, size_t new_size)
+        void (*free) (void *ctx, void *ptr, size_t size)
+
+    ctypedef struct PyDataMem_Handler:
+        char* name
+        npy_uint8 version
+        PyDataMemAllocator allocator
+
+    object PyDataMem_SetHandler(object handler)
+    object PyDataMem_GetHandler()
+
+    # additional datetime related functions are defined below
+
+
+# Typedefs that matches the runtime dtype objects in
+# the numpy module.
+
+# The ones that are commented out needs an IFDEF function
+# in Cython to enable them only on the right systems.
+
+ctypedef npy_int8       int8_t
+ctypedef npy_int16      int16_t
+ctypedef npy_int32      int32_t
+ctypedef npy_int64      int64_t
+#ctypedef npy_int96      int96_t
+#ctypedef npy_int128     int128_t
+
+ctypedef npy_uint8      uint8_t
+ctypedef npy_uint16     uint16_t
+ctypedef npy_uint32     uint32_t
+ctypedef npy_uint64     uint64_t
+#ctypedef npy_uint96     uint96_t
+#ctypedef npy_uint128    uint128_t
+
+ctypedef npy_float32    float32_t
+ctypedef npy_float64    float64_t
+#ctypedef npy_float80    float80_t
+#ctypedef npy_float128   float128_t
+
+ctypedef float complex  complex64_t
+ctypedef double complex complex128_t
+
+ctypedef npy_longlong   longlong_t
+ctypedef npy_ulonglong  ulonglong_t
+
+ctypedef npy_intp       intp_t
+ctypedef npy_uintp      uintp_t
+
+ctypedef npy_double     float_t
+ctypedef npy_double     double_t
+ctypedef npy_longdouble longdouble_t
+
+ctypedef float complex       cfloat_t
+ctypedef double complex      cdouble_t
+ctypedef double complex      complex_t
+ctypedef long double complex clongdouble_t
+
+cdef inline object PyArray_MultiIterNew1(a):
+    return PyArray_MultiIterNew(1, <void*>a)
+
+cdef inline object PyArray_MultiIterNew2(a, b):
+    return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+
+cdef inline object PyArray_MultiIterNew3(a, b, c):
+    return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+
+cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+    return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+
+cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+    return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+
+cdef inline tuple PyDataType_SHAPE(dtype d):
+    if PyDataType_HASSUBARRAY(d):
+        return <tuple>d.subarray.shape
+    else:
+        return ()
+
+
+cdef extern from "numpy/ndarrayobject.h":
+    PyTypeObject PyTimedeltaArrType_Type
+    PyTypeObject PyDatetimeArrType_Type
+    ctypedef int64_t npy_timedelta
+    ctypedef int64_t npy_datetime
+
+cdef extern from "numpy/ndarraytypes.h":
+    ctypedef struct PyArray_DatetimeMetaData:
+        NPY_DATETIMEUNIT base
+        int64_t num
+
+    ctypedef struct npy_datetimestruct:
+        int64_t year
+        int32_t month, day, hour, min, sec, us, ps, as
+
+
+cdef extern from "numpy/arrayscalars.h":
+
+    # abstract types
+    ctypedef class numpy.generic [object PyObject]:
+        pass
+    ctypedef class numpy.number [object PyObject]:
+        pass
+    ctypedef class numpy.integer [object PyObject]:
+        pass
+    ctypedef class numpy.signedinteger [object PyObject]:
+        pass
+    ctypedef class numpy.unsignedinteger [object PyObject]:
+        pass
+    ctypedef class numpy.inexact [object PyObject]:
+        pass
+    ctypedef class numpy.floating [object PyObject]:
+        pass
+    ctypedef class numpy.complexfloating [object PyObject]:
+        pass
+    ctypedef class numpy.flexible [object PyObject]:
+        pass
+    ctypedef class numpy.character [object PyObject]:
+        pass
+
+    ctypedef struct PyDatetimeScalarObject:
+        # PyObject_HEAD
+        npy_datetime obval
+        PyArray_DatetimeMetaData obmeta
+
+    ctypedef struct PyTimedeltaScalarObject:
+        # PyObject_HEAD
+        npy_timedelta obval
+        PyArray_DatetimeMetaData obmeta
+
+    ctypedef enum NPY_DATETIMEUNIT:
+        NPY_FR_Y
+        NPY_FR_M
+        NPY_FR_W
+        NPY_FR_D
+        NPY_FR_B
+        NPY_FR_h
+        NPY_FR_m
+        NPY_FR_s
+        NPY_FR_ms
+        NPY_FR_us
+        NPY_FR_ns
+        NPY_FR_ps
+        NPY_FR_fs
+        NPY_FR_as
+        NPY_FR_GENERIC
+
+
+cdef extern from "numpy/arrayobject.h":
+    # These are part of the C-API defined in `__multiarray_api.h`
+
+    # NumPy internal definitions in datetime_strings.c:
+    int get_datetime_iso_8601_strlen "NpyDatetime_GetDatetimeISO8601StrLen" (
+            int local, NPY_DATETIMEUNIT base)
+    int make_iso_8601_datetime "NpyDatetime_MakeISO8601Datetime" (
+            npy_datetimestruct *dts, char *outstr, npy_intp outlen,
+            int local, int utc, NPY_DATETIMEUNIT base, int tzoffset,
+            NPY_CASTING casting) except -1
+
+    # NumPy internal definition in datetime.c:
+    # May return 1 to indicate that object does not appear to be a datetime
+    # (returns 0 on success).
+    int convert_pydatetime_to_datetimestruct "NpyDatetime_ConvertPyDateTimeToDatetimeStruct" (
+            PyObject *obj, npy_datetimestruct *out,
+            NPY_DATETIMEUNIT *out_bestunit, int apply_tzinfo) except -1
+    int convert_datetime64_to_datetimestruct "NpyDatetime_ConvertDatetime64ToDatetimeStruct" (
+            PyArray_DatetimeMetaData *meta, npy_datetime dt,
+            npy_datetimestruct *out) except -1
+    int convert_datetimestruct_to_datetime64 "NpyDatetime_ConvertDatetimeStructToDatetime64"(
+            PyArray_DatetimeMetaData *meta, const npy_datetimestruct *dts,
+            npy_datetime *out) except -1
+
+
+#
+# ufunc API
+#
+
+cdef extern from "numpy/ufuncobject.h":
+
+    ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *)
+
+    ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]:
+        cdef:
+            int nin, nout, nargs
+            int identity
+            PyUFuncGenericFunction *functions
+            void **data
+            int ntypes
+            int check_return
+            char *name
+            char *types
+            char *doc
+            void *ptr
+            PyObject *obj
+            PyObject *userloops
+
+    cdef enum:
+        PyUFunc_Zero
+        PyUFunc_One
+        PyUFunc_None
+        UFUNC_FPE_DIVIDEBYZERO
+        UFUNC_FPE_OVERFLOW
+        UFUNC_FPE_UNDERFLOW
+        UFUNC_FPE_INVALID
+
+    object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *,
+          void **, char *, int, int, int, int, char *, char *, int)
+    int PyUFunc_RegisterLoopForType(ufunc, int,
+                                    PyUFuncGenericFunction, int *, void *) except -1
+    void PyUFunc_f_f_As_d_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_d_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_f_f \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_g_g \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_F_F_As_D_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_F_F \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_D_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_G_G \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_O_O \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_ff_f_As_dd_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_ff_f \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_dd_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_gg_g \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_FF_F_As_DD_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_DD_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_FF_F \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_GG_G \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_OO_O \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_O_O_method \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_OO_O_method \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_On_Om \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_clearfperr()
+    int PyUFunc_getfperr()
+    int PyUFunc_ReplaceLoopBySignature \
+        (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *)
+    object PyUFunc_FromFuncAndDataAndSignature \
+             (PyUFuncGenericFunction *, void **, char *, int, int, int,
+              int, char *, char *, int, char *)
+
+    int _import_umath() except -1
+
+cdef inline void set_array_base(ndarray arr, object base) except *:
+    Py_INCREF(base) # important to do this before stealing the reference below!
+    PyArray_SetBaseObject(arr, base)
+
+cdef inline object get_array_base(ndarray arr):
+    base = PyArray_BASE(arr)
+    if base is NULL:
+        return None
+    return <object>base
+
+# Versions of the import_* functions which are more suitable for
+# Cython code.
+cdef inline int import_array() except -1:
+    try:
+        __pyx_import_array()
+    except Exception:
+        raise ImportError("numpy._core.multiarray failed to import")
+
+cdef inline int import_umath() except -1:
+    try:
+        _import_umath()
+    except Exception:
+        raise ImportError("numpy._core.umath failed to import")
+
+cdef inline int import_ufunc() except -1:
+    try:
+        _import_umath()
+    except Exception:
+        raise ImportError("numpy._core.umath failed to import")
+
+
+cdef inline bint is_timedelta64_object(object obj) noexcept:
+    """
+    Cython equivalent of `isinstance(obj, np.timedelta64)`
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    bool
+    """
+    return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type)
+
+
+cdef inline bint is_datetime64_object(object obj) noexcept:
+    """
+    Cython equivalent of `isinstance(obj, np.datetime64)`
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    bool
+    """
+    return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type)
+
+
+cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil:
+    """
+    returns the int64 value underlying scalar numpy datetime64 object
+
+    Note that to interpret this as a datetime, the corresponding unit is
+    also needed.  That can be found using `get_datetime64_unit`.
+    """
+    return (<PyDatetimeScalarObject*>obj).obval
+
+
+cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil:
+    """
+    returns the int64 value underlying scalar numpy timedelta64 object
+    """
+    return (<PyTimedeltaScalarObject*>obj).obval
+
+
+cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil:
+    """
+    returns the unit part of the dtype for a numpy datetime64 object.
+    """
+    return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject*>obj).obmeta.base
+
+
+# Iterator API added in v1.6
+ctypedef int (*NpyIter_IterNextFunc)(NpyIter* it) noexcept nogil
+ctypedef void (*NpyIter_GetMultiIndexFunc)(NpyIter* it, npy_intp* outcoords) noexcept nogil
+
+cdef extern from "numpy/arrayobject.h":
+
+    ctypedef struct NpyIter:
+        pass
+
+    cdef enum:
+        NPY_FAIL
+        NPY_SUCCEED
+
+    cdef enum:
+        # Track an index representing C order
+        NPY_ITER_C_INDEX
+        # Track an index representing Fortran order
+        NPY_ITER_F_INDEX
+        # Track a multi-index
+        NPY_ITER_MULTI_INDEX
+        # User code external to the iterator does the 1-dimensional innermost loop
+        NPY_ITER_EXTERNAL_LOOP
+        # Convert all the operands to a common data type
+        NPY_ITER_COMMON_DTYPE
+        # Operands may hold references, requiring API access during iteration
+        NPY_ITER_REFS_OK
+        # Zero-sized operands should be permitted, iteration checks IterSize for 0
+        NPY_ITER_ZEROSIZE_OK
+        # Permits reductions (size-0 stride with dimension size > 1)
+        NPY_ITER_REDUCE_OK
+        # Enables sub-range iteration
+        NPY_ITER_RANGED
+        # Enables buffering
+        NPY_ITER_BUFFERED
+        # When buffering is enabled, grows the inner loop if possible
+        NPY_ITER_GROWINNER
+        # Delay allocation of buffers until first Reset* call
+        NPY_ITER_DELAY_BUFALLOC
+        # When NPY_KEEPORDER is specified, disable reversing negative-stride axes
+        NPY_ITER_DONT_NEGATE_STRIDES
+        NPY_ITER_COPY_IF_OVERLAP
+        # The operand will be read from and written to
+        NPY_ITER_READWRITE
+        # The operand will only be read from
+        NPY_ITER_READONLY
+        # The operand will only be written to
+        NPY_ITER_WRITEONLY
+        # The operand's data must be in native byte order
+        NPY_ITER_NBO
+        # The operand's data must be aligned
+        NPY_ITER_ALIGNED
+        # The operand's data must be contiguous (within the inner loop)
+        NPY_ITER_CONTIG
+        # The operand may be copied to satisfy requirements
+        NPY_ITER_COPY
+        # The operand may be copied with WRITEBACKIFCOPY to satisfy requirements
+        NPY_ITER_UPDATEIFCOPY
+        # Allocate the operand if it is NULL
+        NPY_ITER_ALLOCATE
+        # If an operand is allocated, don't use any subtype
+        NPY_ITER_NO_SUBTYPE
+        # This is a virtual array slot, operand is NULL but temporary data is there
+        NPY_ITER_VIRTUAL
+        # Require that the dimension match the iterator dimensions exactly
+        NPY_ITER_NO_BROADCAST
+        # A mask is being used on this array, affects buffer -> array copy
+        NPY_ITER_WRITEMASKED
+        # This array is the mask for all WRITEMASKED operands
+        NPY_ITER_ARRAYMASK
+        # Assume iterator order data access for COPY_IF_OVERLAP
+        NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE
+
+    # construction and destruction functions
+    NpyIter* NpyIter_New(ndarray arr, npy_uint32 flags, NPY_ORDER order,
+                         NPY_CASTING casting, dtype datatype) except NULL
+    NpyIter* NpyIter_MultiNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags,
+                              NPY_ORDER order, NPY_CASTING casting, npy_uint32*
+                              op_flags, PyArray_Descr** op_dtypes) except NULL
+    NpyIter* NpyIter_AdvancedNew(npy_intp nop, PyArrayObject** op,
+                                 npy_uint32 flags, NPY_ORDER order,
+                                 NPY_CASTING casting, npy_uint32* op_flags,
+                                 PyArray_Descr** op_dtypes, int oa_ndim,
+                                 int** op_axes, const npy_intp* itershape,
+                                 npy_intp buffersize) except NULL
+    NpyIter* NpyIter_Copy(NpyIter* it) except NULL
+    int NpyIter_RemoveAxis(NpyIter* it, int axis) except NPY_FAIL
+    int NpyIter_RemoveMultiIndex(NpyIter* it) except NPY_FAIL
+    int NpyIter_EnableExternalLoop(NpyIter* it) except NPY_FAIL
+    int NpyIter_Deallocate(NpyIter* it) except NPY_FAIL
+    int NpyIter_Reset(NpyIter* it, char** errmsg) except NPY_FAIL
+    int NpyIter_ResetToIterIndexRange(NpyIter* it, npy_intp istart,
+                                      npy_intp iend, char** errmsg) except NPY_FAIL
+    int NpyIter_ResetBasePointers(NpyIter* it, char** baseptrs, char** errmsg) except NPY_FAIL
+    int NpyIter_GotoMultiIndex(NpyIter* it, const npy_intp* multi_index) except NPY_FAIL
+    int NpyIter_GotoIndex(NpyIter* it, npy_intp index) except NPY_FAIL
+    npy_intp NpyIter_GetIterSize(NpyIter* it) nogil
+    npy_intp NpyIter_GetIterIndex(NpyIter* it) nogil
+    void NpyIter_GetIterIndexRange(NpyIter* it, npy_intp* istart,
+                                   npy_intp* iend) nogil
+    int NpyIter_GotoIterIndex(NpyIter* it, npy_intp iterindex) except NPY_FAIL
+    npy_bool NpyIter_HasDelayedBufAlloc(NpyIter* it) nogil
+    npy_bool NpyIter_HasExternalLoop(NpyIter* it) nogil
+    npy_bool NpyIter_HasMultiIndex(NpyIter* it) nogil
+    npy_bool NpyIter_HasIndex(NpyIter* it) nogil
+    npy_bool NpyIter_RequiresBuffering(NpyIter* it) nogil
+    npy_bool NpyIter_IsBuffered(NpyIter* it) nogil
+    npy_bool NpyIter_IsGrowInner(NpyIter* it) nogil
+    npy_intp NpyIter_GetBufferSize(NpyIter* it) nogil
+    int NpyIter_GetNDim(NpyIter* it) nogil
+    int NpyIter_GetNOp(NpyIter* it) nogil
+    npy_intp* NpyIter_GetAxisStrideArray(NpyIter* it, int axis) except NULL
+    int NpyIter_GetShape(NpyIter* it, npy_intp* outshape) nogil
+    PyArray_Descr** NpyIter_GetDescrArray(NpyIter* it)
+    PyArrayObject** NpyIter_GetOperandArray(NpyIter* it)
+    ndarray NpyIter_GetIterView(NpyIter* it, npy_intp i)
+    void NpyIter_GetReadFlags(NpyIter* it, char* outreadflags)
+    void NpyIter_GetWriteFlags(NpyIter* it, char* outwriteflags)
+    int NpyIter_CreateCompatibleStrides(NpyIter* it, npy_intp itemsize,
+                                        npy_intp* outstrides) except NPY_FAIL
+    npy_bool NpyIter_IsFirstVisit(NpyIter* it, int iop) nogil
+    # functions for iterating an NpyIter object
+    NpyIter_IterNextFunc* NpyIter_GetIterNext(NpyIter* it, char** errmsg) except NULL
+    NpyIter_GetMultiIndexFunc* NpyIter_GetGetMultiIndex(NpyIter* it,
+                                                        char** errmsg) except NULL
+    char** NpyIter_GetDataPtrArray(NpyIter* it) nogil
+    char** NpyIter_GetInitialDataPtrArray(NpyIter* it) nogil
+    npy_intp* NpyIter_GetIndexPtr(NpyIter* it)
+    npy_intp* NpyIter_GetInnerStrideArray(NpyIter* it) nogil
+    npy_intp* NpyIter_GetInnerLoopSizePtr(NpyIter* it) nogil
+    void NpyIter_GetInnerFixedStrideArray(NpyIter* it, npy_intp* outstrides) nogil
+    npy_bool NpyIter_IterationNeedsAPI(NpyIter* it) nogil
+    void NpyIter_DebugPrint(NpyIter* it)

mantis_evalkit/lib/python3.10/site-packages/numpy/__init__.py

@@ -0,0 +1,547 @@
+"""
+NumPy
+=====
+
+Provides
+  1. An array object of arbitrary homogeneous items
+  2. Fast mathematical operations over arrays
+  3. Linear Algebra, Fourier Transforms, Random Number Generation
+
+How to use the documentation
+----------------------------
+Documentation is available in two forms: docstrings provided
+with the code, and a loose standing reference guide, available from
+`the NumPy homepage <https://numpy.org>`_.
+
+We recommend exploring the docstrings using
+`IPython <https://ipython.org>`_, an advanced Python shell with
+TAB-completion and introspection capabilities.  See below for further
+instructions.
+
+The docstring examples assume that `numpy` has been imported as ``np``::
+
+  >>> import numpy as np
+
+Code snippets are indicated by three greater-than signs::
+
+  >>> x = 42
+  >>> x = x + 1
+
+Use the built-in ``help`` function to view a function's docstring::
+
+  >>> help(np.sort)
+  ... # doctest: +SKIP
+
+For some objects, ``np.info(obj)`` may provide additional help.  This is
+particularly true if you see the line "Help on ufunc object:" at the top
+of the help() page.  Ufuncs are implemented in C, not Python, for speed.
+The native Python help() does not know how to view their help, but our
+np.info() function does.
+
+Available subpackages
+---------------------
+lib
+    Basic functions used by several sub-packages.
+random
+    Core Random Tools
+linalg
+    Core Linear Algebra Tools
+fft
+    Core FFT routines
+polynomial
+    Polynomial tools
+testing
+    NumPy testing tools
+distutils
+    Enhancements to distutils with support for
+    Fortran compilers support and more (for Python <= 3.11)
+
+Utilities
+---------
+test
+    Run numpy unittests
+show_config
+    Show numpy build configuration
+__version__
+    NumPy version string
+
+Viewing documentation using IPython
+-----------------------------------
+
+Start IPython and import `numpy` usually under the alias ``np``: `import
+numpy as np`.  Then, directly past or use the ``%cpaste`` magic to paste
+examples into the shell.  To see which functions are available in `numpy`,
+type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
+``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
+down the list.  To view the docstring for a function, use
+``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
+the source code).
+
+Copies vs. in-place operation
+-----------------------------
+Most of the functions in `numpy` return a copy of the array argument
+(e.g., `np.sort`).  In-place versions of these functions are often
+available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
+Exceptions to this rule are documented.
+
+"""
+import os
+import sys
+import warnings
+
+from ._globals import _NoValue, _CopyMode
+from ._expired_attrs_2_0 import __expired_attributes__
+
+
+# If a version with git hash was stored, use that instead
+from . import version
+from .version import __version__
+
+# We first need to detect if we're being called as part of the numpy setup
+# procedure itself in a reliable manner.
+try:
+    __NUMPY_SETUP__
+except NameError:
+    __NUMPY_SETUP__ = False
+
+if __NUMPY_SETUP__:
+    sys.stderr.write('Running from numpy source directory.\n')
+else:
+    # Allow distributors to run custom init code before importing numpy._core
+    from . import _distributor_init
+
+    try:
+        from numpy.__config__ import show_config
+    except ImportError as e:
+        msg = """Error importing numpy: you should not try to import numpy from
+        its source directory; please exit the numpy source tree, and relaunch
+        your python interpreter from there."""
+        raise ImportError(msg) from e
+
+    from . import _core
+    from ._core import (
+        False_, ScalarType, True_,
+        abs, absolute, acos, acosh, add, all, allclose,
+        amax, amin, any, arange, arccos, arccosh, arcsin, arcsinh,
+        arctan, arctan2, arctanh, argmax, argmin, argpartition, argsort,
+        argwhere, around, array, array2string, array_equal, array_equiv,
+        array_repr, array_str, asanyarray, asarray, ascontiguousarray,
+        asfortranarray, asin, asinh, atan, atanh, atan2, astype, atleast_1d,
+        atleast_2d, atleast_3d, base_repr, binary_repr, bitwise_and,
+        bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_not,
+        bitwise_or, bitwise_right_shift, bitwise_xor, block, bool, bool_,
+        broadcast, busday_count, busday_offset, busdaycalendar, byte, bytes_,
+        can_cast, cbrt, cdouble, ceil, character, choose, clip, clongdouble,
+        complex128, complex64, complexfloating, compress, concat, concatenate,
+        conj, conjugate, convolve, copysign, copyto, correlate, cos, cosh,
+        count_nonzero, cross, csingle, cumprod, cumsum, cumulative_prod,
+        cumulative_sum, datetime64, datetime_as_string, datetime_data,
+        deg2rad, degrees, diagonal, divide, divmod, dot, double, dtype, e,
+        einsum, einsum_path, empty, empty_like, equal, errstate, euler_gamma,
+        exp, exp2, expm1, fabs, finfo, flatiter, flatnonzero, flexible,
+        float16, float32, float64, float_power, floating, floor, floor_divide,
+        fmax, fmin, fmod, format_float_positional, format_float_scientific,
+        frexp, from_dlpack, frombuffer, fromfile, fromfunction, fromiter,
+        frompyfunc, fromstring, full, full_like, gcd, generic, geomspace,
+        get_printoptions, getbufsize, geterr, geterrcall, greater,
+        greater_equal, half, heaviside, hstack, hypot, identity, iinfo,
+        indices, inexact, inf, inner, int16, int32, int64, int8, int_, intc,
+        integer, intp, invert, is_busday, isclose, isdtype, isfinite,
+        isfortran, isinf, isnan, isnat, isscalar, issubdtype, lcm, ldexp,
+        left_shift, less, less_equal, lexsort, linspace, little_endian, log,
+        log10, log1p, log2, logaddexp, logaddexp2, logical_and, logical_not,
+        logical_or, logical_xor, logspace, long, longdouble, longlong, matmul,
+        matvec, matrix_transpose, max, maximum, may_share_memory, mean, memmap,
+        min, min_scalar_type, minimum, mod, modf, moveaxis, multiply, nan,
+        ndarray, ndim, nditer, negative, nested_iters, newaxis, nextafter,
+        nonzero, not_equal, number, object_, ones, ones_like, outer, partition,
+        permute_dims, pi, positive, pow, power, printoptions, prod,
+        promote_types, ptp, put, putmask, rad2deg, radians, ravel, recarray,
+        reciprocal, record, remainder, repeat, require, reshape, resize,
+        result_type, right_shift, rint, roll, rollaxis, round, sctypeDict,
+        searchsorted, set_printoptions, setbufsize, seterr, seterrcall, shape,
+        shares_memory, short, sign, signbit, signedinteger, sin, single, sinh,
+        size, sort, spacing, sqrt, square, squeeze, stack, std,
+        str_, subtract, sum, swapaxes, take, tan, tanh, tensordot,
+        timedelta64, trace, transpose, true_divide, trunc, typecodes, ubyte,
+        ufunc, uint, uint16, uint32, uint64, uint8, uintc, uintp, ulong,
+        ulonglong, unsignedinteger, unstack, ushort, var, vdot, vecdot,
+        vecmat, void, vstack, where, zeros, zeros_like
+    )
+
+    # NOTE: It's still under discussion whether these aliases
+    # should be removed.
+    for ta in ["float96", "float128", "complex192", "complex256"]:
+        try:
+            globals()[ta] = getattr(_core, ta)
+        except AttributeError:
+            pass
+    del ta
+
+    from . import lib
+    from .lib import scimath as emath
+    from .lib._histograms_impl import (
+        histogram, histogram_bin_edges, histogramdd
+    )
+    from .lib._nanfunctions_impl import (
+        nanargmax, nanargmin, nancumprod, nancumsum, nanmax, nanmean,
+        nanmedian, nanmin, nanpercentile, nanprod, nanquantile, nanstd,
+        nansum, nanvar
+    )
+    from .lib._function_base_impl import (
+        select, piecewise, trim_zeros, copy, iterable, percentile, diff,
+        gradient, angle, unwrap, sort_complex, flip, rot90, extract, place,
+        vectorize, asarray_chkfinite, average, bincount, digitize, cov,
+        corrcoef, median, sinc, hamming, hanning, bartlett, blackman,
+        kaiser, trapezoid, trapz, i0, meshgrid, delete, insert, append,
+        interp, quantile
+    )
+    from .lib._twodim_base_impl import (
+        diag, diagflat, eye, fliplr, flipud, tri, triu, tril, vander,
+        histogram2d, mask_indices, tril_indices, tril_indices_from,
+        triu_indices, triu_indices_from
+    )
+    from .lib._shape_base_impl import (
+        apply_over_axes, apply_along_axis, array_split, column_stack, dsplit,
+        dstack, expand_dims, hsplit, kron, put_along_axis, row_stack, split,
+        take_along_axis, tile, vsplit
+    )
+    from .lib._type_check_impl import (
+        iscomplexobj, isrealobj, imag, iscomplex, isreal, nan_to_num, real,
+        real_if_close, typename, mintypecode, common_type
+    )
+    from .lib._arraysetops_impl import (
+        ediff1d, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d,
+        unique, unique_all, unique_counts, unique_inverse, unique_values
+    )
+    from .lib._ufunclike_impl import fix, isneginf, isposinf
+    from .lib._arraypad_impl import pad
+    from .lib._utils_impl import (
+        show_runtime, get_include, info
+    )
+    from .lib._stride_tricks_impl import (
+        broadcast_arrays, broadcast_shapes, broadcast_to
+    )
+    from .lib._polynomial_impl import (
+        poly, polyint, polyder, polyadd, polysub, polymul, polydiv, polyval,
+        polyfit, poly1d, roots
+    )
+    from .lib._npyio_impl import (
+        savetxt, loadtxt, genfromtxt, load, save, savez, packbits,
+        savez_compressed, unpackbits, fromregex
+    )
+    from .lib._index_tricks_impl import (
+        diag_indices_from, diag_indices, fill_diagonal, ndindex, ndenumerate,
+        ix_, c_, r_, s_, ogrid, mgrid, unravel_index, ravel_multi_index,
+        index_exp
+    )
+
+    from . import matrixlib as _mat
+    from .matrixlib import (
+        asmatrix, bmat, matrix
+    )
+
+    # public submodules are imported lazily, therefore are accessible from
+    # __getattr__. Note that `distutils` (deprecated) and `array_api`
+    # (experimental label) are not added here, because `from numpy import *`
+    # must not raise any warnings - that's too disruptive.
+    __numpy_submodules__ = {
+        "linalg", "fft", "dtypes", "random", "polynomial", "ma",
+        "exceptions", "lib", "ctypeslib", "testing", "typing",
+        "f2py", "test", "rec", "char", "core", "strings",
+    }
+
+    # We build warning messages for former attributes
+    _msg = (
+        "module 'numpy' has no attribute '{n}'.\n"
+        "`np.{n}` was a deprecated alias for the builtin `{n}`. "
+        "To avoid this error in existing code, use `{n}` by itself. "
+        "Doing this will not modify any behavior and is safe. {extended_msg}\n"
+        "The aliases was originally deprecated in NumPy 1.20; for more "
+        "details and guidance see the original release note at:\n"
+        "    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations")
+
+    _specific_msg = (
+        "If you specifically wanted the numpy scalar type, use `np.{}` here.")
+
+    _int_extended_msg = (
+        "When replacing `np.{}`, you may wish to use e.g. `np.int64` "
+        "or `np.int32` to specify the precision. If you wish to review "
+        "your current use, check the release note link for "
+        "additional information.")
+
+    _type_info = [
+        ("object", ""),  # The NumPy scalar only exists by name.
+        ("float", _specific_msg.format("float64")),
+        ("complex", _specific_msg.format("complex128")),
+        ("str", _specific_msg.format("str_")),
+        ("int", _int_extended_msg.format("int"))]
+
+    __former_attrs__ = {
+         n: _msg.format(n=n, extended_msg=extended_msg)
+         for n, extended_msg in _type_info
+     }
+
+
+    # Some of these could be defined right away, but most were aliases to
+    # the Python objects and only removed in NumPy 1.24.  Defining them should
+    # probably wait for NumPy 1.26 or 2.0.
+    # When defined, these should possibly not be added to `__all__` to avoid
+    # import with `from numpy import *`.
+    __future_scalars__ = {"str", "bytes", "object"}
+
+    __array_api_version__ = "2023.12"
+
+    from ._array_api_info import __array_namespace_info__
+
+    # now that numpy core module is imported, can initialize limits
+    _core.getlimits._register_known_types()
+
+    __all__ = list(
+        __numpy_submodules__ |
+        set(_core.__all__) |
+        set(_mat.__all__) |
+        set(lib._histograms_impl.__all__) |
+        set(lib._nanfunctions_impl.__all__) |
+        set(lib._function_base_impl.__all__) |
+        set(lib._twodim_base_impl.__all__) |
+        set(lib._shape_base_impl.__all__) |
+        set(lib._type_check_impl.__all__) |
+        set(lib._arraysetops_impl.__all__) |
+        set(lib._ufunclike_impl.__all__) |
+        set(lib._arraypad_impl.__all__) |
+        set(lib._utils_impl.__all__) |
+        set(lib._stride_tricks_impl.__all__) |
+        set(lib._polynomial_impl.__all__) |
+        set(lib._npyio_impl.__all__) |
+        set(lib._index_tricks_impl.__all__) |
+        {"emath", "show_config", "__version__", "__array_namespace_info__"}
+    )
+
+    # Filter out Cython harmless warnings
+    warnings.filterwarnings("ignore", message="numpy.dtype size changed")
+    warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
+    warnings.filterwarnings("ignore", message="numpy.ndarray size changed")
+
+    def __getattr__(attr):
+        # Warn for expired attributes
+        import warnings
+
+        if attr == "linalg":
+            import numpy.linalg as linalg
+            return linalg
+        elif attr == "fft":
+            import numpy.fft as fft
+            return fft
+        elif attr == "dtypes":
+            import numpy.dtypes as dtypes
+            return dtypes
+        elif attr == "random":
+            import numpy.random as random
+            return random
+        elif attr == "polynomial":
+            import numpy.polynomial as polynomial
+            return polynomial
+        elif attr == "ma":
+            import numpy.ma as ma
+            return ma
+        elif attr == "ctypeslib":
+            import numpy.ctypeslib as ctypeslib
+            return ctypeslib
+        elif attr == "exceptions":
+            import numpy.exceptions as exceptions
+            return exceptions
+        elif attr == "testing":
+            import numpy.testing as testing
+            return testing
+        elif attr == "matlib":
+            import numpy.matlib as matlib
+            return matlib
+        elif attr == "f2py":
+            import numpy.f2py as f2py
+            return f2py
+        elif attr == "typing":
+            import numpy.typing as typing
+            return typing
+        elif attr == "rec":
+            import numpy.rec as rec
+            return rec
+        elif attr == "char":
+            import numpy.char as char
+            return char
+        elif attr == "array_api":
+            raise AttributeError("`numpy.array_api` is not available from "
+                                 "numpy 2.0 onwards", name=None)
+        elif attr == "core":
+            import numpy.core as core
+            return core
+        elif attr == "strings":
+            import numpy.strings as strings
+            return strings
+        elif attr == "distutils":
+            if 'distutils' in __numpy_submodules__:
+                import numpy.distutils as distutils
+                return distutils
+            else:
+                raise AttributeError("`numpy.distutils` is not available from "
+                                     "Python 3.12 onwards", name=None)
+
+        if attr in __future_scalars__:
+            # And future warnings for those that will change, but also give
+            # the AttributeError
+            warnings.warn(
+                f"In the future `np.{attr}` will be defined as the "
+                "corresponding NumPy scalar.", FutureWarning, stacklevel=2)
+
+        if attr in __former_attrs__:
+            raise AttributeError(__former_attrs__[attr], name=None)
+
+        if attr in __expired_attributes__:
+            raise AttributeError(
+                f"`np.{attr}` was removed in the NumPy 2.0 release. "
+                f"{__expired_attributes__[attr]}",
+                name=None
+            )
+
+        if attr == "chararray":
+            warnings.warn(
+                "`np.chararray` is deprecated and will be removed from "
+                "the main namespace in the future. Use an array with a string "
+                "or bytes dtype instead.", DeprecationWarning, stacklevel=2)
+            import numpy.char as char
+            return char.chararray
+
+        raise AttributeError("module {!r} has no attribute "
+                             "{!r}".format(__name__, attr))
+
+    def __dir__():
+        public_symbols = (
+            globals().keys() | __numpy_submodules__
+        )
+        public_symbols -= {
+            "matrixlib", "matlib", "tests", "conftest", "version",
+            "compat", "distutils", "array_api"
+        }
+        return list(public_symbols)
+
+    # Pytest testing
+    from numpy._pytesttester import PytestTester
+    test = PytestTester(__name__)
+    del PytestTester
+
+    def _sanity_check():
+        """
+        Quick sanity checks for common bugs caused by environment.
+        There are some cases e.g. with wrong BLAS ABI that cause wrong
+        results under specific runtime conditions that are not necessarily
+        achieved during test suite runs, and it is useful to catch those early.
+
+        See https://github.com/numpy/numpy/issues/8577 and other
+        similar bug reports.
+
+        """
+        try:
+            x = ones(2, dtype=float32)
+            if not abs(x.dot(x) - float32(2.0)) < 1e-5:
+                raise AssertionError
+        except AssertionError:
+            msg = ("The current Numpy installation ({!r}) fails to "
+                   "pass simple sanity checks. This can be caused for example "
+                   "by incorrect BLAS library being linked in, or by mixing "
+                   "package managers (pip, conda, apt, ...). Search closed "
+                   "numpy issues for similar problems.")
+            raise RuntimeError(msg.format(__file__)) from None
+
+    _sanity_check()
+    del _sanity_check
+
+    def _mac_os_check():
+        """
+        Quick Sanity check for Mac OS look for accelerate build bugs.
+        Testing numpy polyfit calls init_dgelsd(LAPACK)
+        """
+        try:
+            c = array([3., 2., 1.])
+            x = linspace(0, 2, 5)
+            y = polyval(c, x)
+            _ = polyfit(x, y, 2, cov=True)
+        except ValueError:
+            pass
+
+    if sys.platform == "darwin":
+        from . import exceptions
+        with warnings.catch_warnings(record=True) as w:
+            _mac_os_check()
+            # Throw runtime error, if the test failed Check for warning and error_message
+            if len(w) > 0:
+                for _wn in w:
+                    if _wn.category is exceptions.RankWarning:
+                        # Ignore other warnings, they may not be relevant (see gh-25433).
+                        error_message = (
+                            f"{_wn.category.__name__}: {_wn.message}"
+                        )
+                        msg = (
+                            "Polyfit sanity test emitted a warning, most likely due "
+                            "to using a buggy Accelerate backend."
+                            "\nIf you compiled yourself, more information is available at:"
+                            "\nhttps://numpy.org/devdocs/building/index.html"
+                            "\nOtherwise report this to the vendor "
+                            "that provided NumPy.\n\n{}\n".format(error_message))
+                        raise RuntimeError(msg)
+                del _wn
+            del w
+    del _mac_os_check
+
+    def hugepage_setup():
+        """
+        We usually use madvise hugepages support, but on some old kernels it
+        is slow and thus better avoided. Specifically kernel version 4.6
+        had a bug fix which probably fixed this:
+        https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff
+        """
+        use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None)
+        if sys.platform == "linux" and use_hugepage is None:
+            # If there is an issue with parsing the kernel version,
+            # set use_hugepage to 0. Usage of LooseVersion will handle
+            # the kernel version parsing better, but avoided since it
+            # will increase the import time.
+            # See: #16679 for related discussion.
+            try:
+                use_hugepage = 1
+                kernel_version = os.uname().release.split(".")[:2]
+                kernel_version = tuple(int(v) for v in kernel_version)
+                if kernel_version < (4, 6):
+                    use_hugepage = 0
+            except ValueError:
+                use_hugepage = 0
+        elif use_hugepage is None:
+            # This is not Linux, so it should not matter, just enable anyway
+            use_hugepage = 1
+        else:
+            use_hugepage = int(use_hugepage)
+        return use_hugepage
+
+    # Note that this will currently only make a difference on Linux
+    _core.multiarray._set_madvise_hugepage(hugepage_setup())
+    del hugepage_setup
+
+    # Give a warning if NumPy is reloaded or imported on a sub-interpreter
+    # We do this from python, since the C-module may not be reloaded and
+    # it is tidier organized.
+    _core.multiarray._multiarray_umath._reload_guard()
+
+    # TODO: Remove the environment variable entirely now that it is "weak"
+    if (os.environ.get("NPY_PROMOTION_STATE", "weak") != "weak"):
+        warnings.warn(
+            "NPY_PROMOTION_STATE was a temporary feature for NumPy 2.0 "
+            "transition and is ignored after NumPy 2.2.",
+            UserWarning, stacklevel=2)
+
+    # Tell PyInstaller where to find hook-numpy.py
+    def _pyinstaller_hooks_dir():
+        from pathlib import Path
+        return [str(Path(__file__).with_name("_pyinstaller").resolve())]
+
+
+# Remove symbols imported for internal use
+del os, sys, warnings

mantis_evalkit/lib/python3.10/site-packages/numpy/_configtool.py

@@ -0,0 +1,39 @@
+import argparse
+from pathlib import Path
+import sys
+
+from .version import __version__
+from .lib._utils_impl import get_include
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version and exit.",
+    )
+    parser.add_argument(
+        "--cflags",
+        action="store_true",
+        help="Compile flag needed when using the NumPy headers.",
+    )
+    parser.add_argument(
+        "--pkgconfigdir",
+        action="store_true",
+        help=("Print the pkgconfig directory in which `numpy.pc` is stored "
+              "(useful for setting $PKG_CONFIG_PATH)."),
+    )
+    args = parser.parse_args()
+    if not sys.argv[1:]:
+        parser.print_help()
+    if args.cflags:
+        print("-I" + get_include())
+    if args.pkgconfigdir:
+        _path = Path(get_include()) / '..' / 'lib' / 'pkgconfig'
+        print(_path.resolve())
+
+
+if __name__ == "__main__":
+    main()

mantis_evalkit/lib/python3.10/site-packages/numpy/_expired_attrs_2_0.py

@@ -0,0 +1,80 @@
+"""
+Dict of expired attributes that are discontinued since 2.0 release.
+Each item is associated with a migration note.
+"""
+
+__expired_attributes__ = {
+    "geterrobj": "Use the np.errstate context manager instead.",
+    "seterrobj": "Use the np.errstate context manager instead.",
+    "cast": "Use `np.asarray(arr, dtype=dtype)` instead.",
+    "source": "Use `inspect.getsource` instead.",
+    "lookfor":  "Search NumPy's documentation directly.",
+    "who": "Use an IDE variable explorer or `locals()` instead.",
+    "fastCopyAndTranspose": "Use `arr.T.copy()` instead.",
+    "set_numeric_ops":
+        "For the general case, use `PyUFunc_ReplaceLoopBySignature`. "
+        "For ndarray subclasses, define the ``__array_ufunc__`` method "
+        "and override the relevant ufunc.",
+    "NINF": "Use `-np.inf` instead.",
+    "PINF": "Use `np.inf` instead.",
+    "NZERO": "Use `-0.0` instead.",
+    "PZERO": "Use `0.0` instead.",
+    "add_newdoc":
+        "It's still available as `np.lib.add_newdoc`.",
+    "add_docstring":
+        "It's still available as `np.lib.add_docstring`.",
+    "add_newdoc_ufunc":
+        "It's an internal function and doesn't have a replacement.",
+    "compat": "There's no replacement, as Python 2 is no longer supported.",
+    "safe_eval": "Use `ast.literal_eval` instead.",
+    "float_": "Use `np.float64` instead.",
+    "complex_": "Use `np.complex128` instead.",
+    "longfloat": "Use `np.longdouble` instead.",
+    "singlecomplex": "Use `np.complex64` instead.",
+    "cfloat": "Use `np.complex128` instead.",
+    "longcomplex": "Use `np.clongdouble` instead.",
+    "clongfloat": "Use `np.clongdouble` instead.",
+    "string_": "Use `np.bytes_` instead.",
+    "unicode_": "Use `np.str_` instead.",
+    "Inf": "Use `np.inf` instead.",
+    "Infinity": "Use `np.inf` instead.",
+    "NaN": "Use `np.nan` instead.",
+    "infty": "Use `np.inf` instead.",
+    "issctype": "Use `issubclass(rep, np.generic)` instead.",
+    "maximum_sctype":
+        "Use a specific dtype instead. You should avoid relying "
+        "on any implicit mechanism and select the largest dtype of "
+        "a kind explicitly in the code.",
+    "obj2sctype": "Use `np.dtype(obj).type` instead.",
+    "sctype2char": "Use `np.dtype(obj).char` instead.",
+    "sctypes": "Access dtypes explicitly instead.",
+    "issubsctype": "Use `np.issubdtype` instead.",
+    "set_string_function":
+        "Use `np.set_printoptions` instead with a formatter for "
+        "custom printing of NumPy objects.",
+    "asfarray": "Use `np.asarray` with a proper dtype instead.",
+    "issubclass_": "Use `issubclass` builtin instead.",
+    "tracemalloc_domain": "It's now available from `np.lib`.",
+    "mat": "Use `np.asmatrix` instead.",
+    "recfromcsv": "Use `np.genfromtxt` with comma delimiter instead.",
+    "recfromtxt": "Use `np.genfromtxt` instead.",
+    "deprecate": "Emit `DeprecationWarning` with `warnings.warn` directly, "
+        "or use `typing.deprecated`.",
+    "deprecate_with_doc": "Emit `DeprecationWarning` with `warnings.warn` "
+        "directly, or use `typing.deprecated`.",
+    "disp": "Use your own printing function instead.",
+    "find_common_type":
+        "Use `numpy.promote_types` or `numpy.result_type` instead. "
+        "To achieve semantics for the `scalar_types` argument, use "
+        "`numpy.result_type` and pass the Python values `0`, `0.0`, or `0j`.",
+    "round_": "Use `np.round` instead.",
+    "get_array_wrap": "",
+    "DataSource": "It's still available as `np.lib.npyio.DataSource`.",
+    "nbytes": "Use `np.dtype(<dtype>).itemsize` instead.",
+    "byte_bounds": "Now it's available under `np.lib.array_utils.byte_bounds`",
+    "compare_chararrays":
+        "It's still available as `np.char.compare_chararrays`.",
+    "format_parser": "It's still available as `np.rec.format_parser`.",
+    "alltrue": "Use `np.all` instead.",
+    "sometrue": "Use `np.any` instead.",
+}

mantis_evalkit/lib/python3.10/site-packages/numpy/_globals.py

@@ -0,0 +1,95 @@
+"""
+Module defining global singleton classes.
+
+This module raises a RuntimeError if an attempt to reload it is made. In that
+way the identities of the classes defined here are fixed and will remain so
+even if numpy itself is reloaded. In particular, a function like the following
+will still work correctly after numpy is reloaded::
+
+    def foo(arg=np._NoValue):
+        if arg is np._NoValue:
+            ...
+
+That was not the case when the singleton classes were defined in the numpy
+``__init__.py`` file. See gh-7844 for a discussion of the reload problem that
+motivated this module.
+
+"""
+import enum
+
+from ._utils import set_module as _set_module
+
+__all__ = ['_NoValue', '_CopyMode']
+
+
+# Disallow reloading this module so as to preserve the identities of the
+# classes defined here.
+if '_is_loaded' in globals():
+    raise RuntimeError('Reloading numpy._globals is not allowed')
+_is_loaded = True
+
+
+class _NoValueType:
+    """Special keyword value.
+
+    The instance of this class may be used as the default value assigned to a
+    keyword if no other obvious default (e.g., `None`) is suitable,
+
+    Common reasons for using this keyword are:
+
+    - A new keyword is added to a function, and that function forwards its
+      inputs to another function or method which can be defined outside of
+      NumPy. For example, ``np.std(x)`` calls ``x.std``, so when a ``keepdims``
+      keyword was added that could only be forwarded if the user explicitly
+      specified ``keepdims``; downstream array libraries may not have added
+      the same keyword, so adding ``x.std(..., keepdims=keepdims)``
+      unconditionally could have broken previously working code.
+    - A keyword is being deprecated, and a deprecation warning must only be
+      emitted when the keyword is used.
+
+    """
+    __instance = None
+    def __new__(cls):
+        # ensure that only one instance exists
+        if not cls.__instance:
+            cls.__instance = super().__new__(cls)
+        return cls.__instance
+
+    def __repr__(self):
+        return "<no value>"
+
+
+_NoValue = _NoValueType()
+
+
+@_set_module("numpy")
+class _CopyMode(enum.Enum):
+    """
+    An enumeration for the copy modes supported
+    by numpy.copy() and numpy.array(). The following three modes are supported,
+
+    - ALWAYS: This means that a deep copy of the input
+              array will always be taken.
+    - IF_NEEDED: This means that a deep copy of the input
+                 array will be taken only if necessary.
+    - NEVER: This means that the deep copy will never be taken.
+             If a copy cannot be avoided then a `ValueError` will be
+             raised.
+
+    Note that the buffer-protocol could in theory do copies.  NumPy currently
+    assumes an object exporting the buffer protocol will never do this.
+    """
+
+    ALWAYS = True
+    NEVER = False
+    IF_NEEDED = 2
+
+    def __bool__(self):
+        # For backwards compatibility
+        if self == _CopyMode.ALWAYS:
+            return True
+
+        if self == _CopyMode.NEVER:
+            return False
+
+        raise ValueError(f"{self} is neither True nor False.")

mantis_evalkit/lib/python3.10/site-packages/numpy/exceptions.py

@@ -0,0 +1,247 @@
+"""
+Exceptions and Warnings (:mod:`numpy.exceptions`)
+=================================================
+
+General exceptions used by NumPy.  Note that some exceptions may be module
+specific, such as linear algebra errors.
+
+.. versionadded:: NumPy 1.25
+
+    The exceptions module is new in NumPy 1.25.  Older exceptions remain
+    available through the main NumPy namespace for compatibility.
+
+.. currentmodule:: numpy.exceptions
+
+Warnings
+--------
+.. autosummary::
+   :toctree: generated/
+
+   ComplexWarning             Given when converting complex to real.
+   VisibleDeprecationWarning  Same as a DeprecationWarning, but more visible.
+   RankWarning                Issued when the design matrix is rank deficient.
+
+Exceptions
+----------
+.. autosummary::
+   :toctree: generated/
+
+    AxisError          Given when an axis was invalid.
+    DTypePromotionError   Given when no common dtype could be found.
+    TooHardError       Error specific to `numpy.shares_memory`.
+
+"""
+
+
+__all__ = [
+    "ComplexWarning", "VisibleDeprecationWarning", "ModuleDeprecationWarning",
+    "TooHardError", "AxisError", "DTypePromotionError"]
+
+
+# Disallow reloading this module so as to preserve the identities of the
+# classes defined here.
+if '_is_loaded' in globals():
+    raise RuntimeError('Reloading numpy._globals is not allowed')
+_is_loaded = True
+
+
+class ComplexWarning(RuntimeWarning):
+    """
+    The warning raised when casting a complex dtype to a real dtype.
+
+    As implemented, casting a complex number to a real discards its imaginary
+    part, but this behavior may not be what the user actually wants.
+
+    """
+    pass
+
+
+class ModuleDeprecationWarning(DeprecationWarning):
+    """Module deprecation warning.
+
+    .. warning::
+
+        This warning should not be used, since nose testing is not relevant
+        anymore.
+
+    The nose tester turns ordinary Deprecation warnings into test failures.
+    That makes it hard to deprecate whole modules, because they get
+    imported by default. So this is a special Deprecation warning that the
+    nose tester will let pass without making tests fail.
+
+    """
+    pass
+
+
+class VisibleDeprecationWarning(UserWarning):
+    """Visible deprecation warning.
+
+    By default, python will not show deprecation warnings, so this class
+    can be used when a very visible warning is helpful, for example because
+    the usage is most likely a user bug.
+
+    """
+    pass
+
+
+class RankWarning(RuntimeWarning):
+    """Matrix rank warning.
+
+    Issued by polynomial functions when the design matrix is rank deficient.
+
+    """
+    pass
+
+
+# Exception used in shares_memory()
+class TooHardError(RuntimeError):
+    """max_work was exceeded.
+
+    This is raised whenever the maximum number of candidate solutions
+    to consider specified by the ``max_work`` parameter is exceeded.
+    Assigning a finite number to max_work may have caused the operation
+    to fail.
+
+    """
+    pass
+
+
+class AxisError(ValueError, IndexError):
+    """Axis supplied was invalid.
+
+    This is raised whenever an ``axis`` parameter is specified that is larger
+    than the number of array dimensions.
+    For compatibility with code written against older numpy versions, which
+    raised a mixture of :exc:`ValueError` and :exc:`IndexError` for this
+    situation, this exception subclasses both to ensure that
+    ``except ValueError`` and ``except IndexError`` statements continue
+    to catch ``AxisError``.
+
+    Parameters
+    ----------
+    axis : int or str
+        The out of bounds axis or a custom exception message.
+        If an axis is provided, then `ndim` should be specified as well.
+    ndim : int, optional
+        The number of array dimensions.
+    msg_prefix : str, optional
+        A prefix for the exception message.
+
+    Attributes
+    ----------
+    axis : int, optional
+        The out of bounds axis or ``None`` if a custom exception
+        message was provided. This should be the axis as passed by
+        the user, before any normalization to resolve negative indices.
+
+        .. versionadded:: 1.22
+    ndim : int, optional
+        The number of array dimensions or ``None`` if a custom exception
+        message was provided.
+
+        .. versionadded:: 1.22
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> array_1d = np.arange(10)
+    >>> np.cumsum(array_1d, axis=1)
+    Traceback (most recent call last):
+      ...
+    numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1
+
+    Negative axes are preserved:
+
+    >>> np.cumsum(array_1d, axis=-2)
+    Traceback (most recent call last):
+      ...
+    numpy.exceptions.AxisError: axis -2 is out of bounds for array of dimension 1
+
+    The class constructor generally takes the axis and arrays'
+    dimensionality as arguments:
+
+    >>> print(np.exceptions.AxisError(2, 1, msg_prefix='error'))
+    error: axis 2 is out of bounds for array of dimension 1
+
+    Alternatively, a custom exception message can be passed:
+
+    >>> print(np.exceptions.AxisError('Custom error message'))
+    Custom error message
+
+    """
+
+    __slots__ = ("axis", "ndim", "_msg")
+
+    def __init__(self, axis, ndim=None, msg_prefix=None):
+        if ndim is msg_prefix is None:
+            # single-argument form: directly set the error message
+            self._msg = axis
+            self.axis = None
+            self.ndim = None
+        else:
+            self._msg = msg_prefix
+            self.axis = axis
+            self.ndim = ndim
+
+    def __str__(self):
+        axis = self.axis
+        ndim = self.ndim
+
+        if axis is ndim is None:
+            return self._msg
+        else:
+            msg = f"axis {axis} is out of bounds for array of dimension {ndim}"
+            if self._msg is not None:
+                msg = f"{self._msg}: {msg}"
+            return msg
+
+
+class DTypePromotionError(TypeError):
+    """Multiple DTypes could not be converted to a common one.
+
+    This exception derives from ``TypeError`` and is raised whenever dtypes
+    cannot be converted to a single common one.  This can be because they
+    are of a different category/class or incompatible instances of the same
+    one (see Examples).
+
+    Notes
+    -----
+    Many functions will use promotion to find the correct result and
+    implementation.  For these functions the error will typically be chained
+    with a more specific error indicating that no implementation was found
+    for the input dtypes.
+
+    Typically promotion should be considered "invalid" between the dtypes of
+    two arrays when `arr1 == arr2` can safely return all ``False`` because the
+    dtypes are fundamentally different.
+
+    Examples
+    --------
+    Datetimes and complex numbers are incompatible classes and cannot be
+    promoted:
+
+    >>> import numpy as np
+    >>> np.result_type(np.dtype("M8[s]"), np.complex128)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+     ...
+    DTypePromotionError: The DType <class 'numpy.dtype[datetime64]'> could not
+    be promoted by <class 'numpy.dtype[complex128]'>. This means that no common
+    DType exists for the given inputs. For example they cannot be stored in a
+    single array unless the dtype is `object`. The full list of DTypes is:
+    (<class 'numpy.dtype[datetime64]'>, <class 'numpy.dtype[complex128]'>)
+
+    For example for structured dtypes, the structure can mismatch and the
+    same ``DTypePromotionError`` is given when two structured dtypes with
+    a mismatch in their number of fields is given:
+
+    >>> dtype1 = np.dtype([("field1", np.float64), ("field2", np.int64)])
+    >>> dtype2 = np.dtype([("field1", np.float64)])
+    >>> np.promote_types(dtype1, dtype2)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+     ...
+    DTypePromotionError: field names `('field1', 'field2')` and `('field1',)`
+    mismatch.
+
+    """  # NOQA
+    pass

mantis_evalkit/lib/python3.10/site-packages/omegaconf/base.py

@@ -0,0 +1,962 @@
+import copy
+import sys
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type, Union
+
+from antlr4 import ParserRuleContext
+
+from ._utils import (
+    _DEFAULT_MARKER_,
+    NoneType,
+    ValueKind,
+    _get_value,
+    _is_interpolation,
+    _is_missing_value,
+    _is_special,
+    format_and_raise,
+    get_value_kind,
+    is_union_annotation,
+    is_valid_value_annotation,
+    split_key,
+    type_str,
+)
+from .errors import (
+    ConfigKeyError,
+    ConfigTypeError,
+    InterpolationKeyError,
+    InterpolationResolutionError,
+    InterpolationToMissingValueError,
+    InterpolationValidationError,
+    MissingMandatoryValue,
+    UnsupportedInterpolationType,
+    ValidationError,
+)
+from .grammar.gen.OmegaConfGrammarParser import OmegaConfGrammarParser
+from .grammar_parser import parse
+from .grammar_visitor import GrammarVisitor
+
+DictKeyType = Union[str, bytes, int, Enum, float, bool]
+
+
+@dataclass
+class Metadata:
+
+    ref_type: Union[Type[Any], Any]
+
+    object_type: Union[Type[Any], Any]
+
+    optional: bool
+
+    key: Any
+
+    # Flags have 3 modes:
+    #   unset : inherit from parent (None if no parent specifies)
+    #   set to true: flag is true
+    #   set to false: flag is false
+    flags: Optional[Dict[str, bool]] = None
+
+    # If True, when checking the value of a flag, if the flag is not set None is returned
+    # otherwise, the parent node is queried.
+    flags_root: bool = False
+
+    resolver_cache: Dict[str, Any] = field(default_factory=lambda: defaultdict(dict))
+
+    def __post_init__(self) -> None:
+        if self.flags is None:
+            self.flags = {}
+
+    @property
+    def type_hint(self) -> Union[Type[Any], Any]:
+        """Compute `type_hint` from `self.optional` and `self.ref_type`"""
+        # For compatibility with pickled OmegaConf objects created using older
+        # versions of OmegaConf, we store `ref_type` and `object_type`
+        # separately (rather than storing `type_hint` directly).
+        if self.optional:
+            return Optional[self.ref_type]
+        else:
+            return self.ref_type
+
+
+@dataclass
+class ContainerMetadata(Metadata):
+    key_type: Any = None
+    element_type: Any = None
+
+    def __post_init__(self) -> None:
+        if self.ref_type is None:
+            self.ref_type = Any
+        assert self.key_type is Any or isinstance(self.key_type, type)
+        if self.element_type is not None:
+            if not is_valid_value_annotation(self.element_type):
+                raise ValidationError(
+                    f"Unsupported value type: '{type_str(self.element_type, include_module_name=True)}'"
+                )
+
+        if self.flags is None:
+            self.flags = {}
+
+
+class Node(ABC):
+    _metadata: Metadata
+
+    _parent: Optional["Box"]
+    _flags_cache: Optional[Dict[str, Optional[bool]]]
+
+    def __init__(self, parent: Optional["Box"], metadata: Metadata):
+        self.__dict__["_metadata"] = metadata
+        self.__dict__["_parent"] = parent
+        self.__dict__["_flags_cache"] = None
+
+    def __getstate__(self) -> Dict[str, Any]:
+        # Overridden to ensure that the flags cache is cleared on serialization.
+        state_dict = copy.copy(self.__dict__)
+        del state_dict["_flags_cache"]
+        return state_dict
+
+    def __setstate__(self, state_dict: Dict[str, Any]) -> None:
+        self.__dict__.update(state_dict)
+        self.__dict__["_flags_cache"] = None
+
+    def _set_parent(self, parent: Optional["Box"]) -> None:
+        assert parent is None or isinstance(parent, Box)
+        self.__dict__["_parent"] = parent
+        self._invalidate_flags_cache()
+
+    def _invalidate_flags_cache(self) -> None:
+        self.__dict__["_flags_cache"] = None
+
+    def _get_parent(self) -> Optional["Box"]:
+        parent = self.__dict__["_parent"]
+        assert parent is None or isinstance(parent, Box)
+        return parent
+
+    def _get_parent_container(self) -> Optional["Container"]:
+        """
+        Like _get_parent, but returns the grandparent
+        in the case where `self` is wrapped by a UnionNode.
+        """
+        parent = self.__dict__["_parent"]
+        assert parent is None or isinstance(parent, Box)
+
+        if isinstance(parent, UnionNode):
+            grandparent = parent.__dict__["_parent"]
+            assert grandparent is None or isinstance(grandparent, Container)
+            return grandparent
+        else:
+            assert parent is None or isinstance(parent, Container)
+            return parent
+
+    def _set_flag(
+        self,
+        flags: Union[List[str], str],
+        values: Union[List[Optional[bool]], Optional[bool]],
+    ) -> "Node":
+        if isinstance(flags, str):
+            flags = [flags]
+
+        if values is None or isinstance(values, bool):
+            values = [values]
+
+        if len(values) == 1:
+            values = len(flags) * values
+
+        if len(flags) != len(values):
+            raise ValueError("Inconsistent lengths of input flag names and values")
+
+        for idx, flag in enumerate(flags):
+            value = values[idx]
+            if value is None:
+                assert self._metadata.flags is not None
+                if flag in self._metadata.flags:
+                    del self._metadata.flags[flag]
+            else:
+                assert self._metadata.flags is not None
+                self._metadata.flags[flag] = value
+        self._invalidate_flags_cache()
+        return self
+
+    def _get_node_flag(self, flag: str) -> Optional[bool]:
+        """
+        :param flag: flag to inspect
+        :return: the state of the flag on this node.
+        """
+        assert self._metadata.flags is not None
+        return self._metadata.flags.get(flag)
+
+    def _get_flag(self, flag: str) -> Optional[bool]:
+        cache = self.__dict__["_flags_cache"]
+        if cache is None:
+            cache = self.__dict__["_flags_cache"] = {}
+
+        ret = cache.get(flag, _DEFAULT_MARKER_)
+        if ret is _DEFAULT_MARKER_:
+            ret = self._get_flag_no_cache(flag)
+            cache[flag] = ret
+        assert ret is None or isinstance(ret, bool)
+        return ret
+
+    def _get_flag_no_cache(self, flag: str) -> Optional[bool]:
+        """
+        Returns True if this config node flag is set
+        A flag is set if node.set_flag(True) was called
+        or one if it's parents is flag is set
+        :return:
+        """
+        flags = self._metadata.flags
+        assert flags is not None
+        if flag in flags and flags[flag] is not None:
+            return flags[flag]
+
+        if self._is_flags_root():
+            return None
+
+        parent = self._get_parent()
+        if parent is None:
+            return None
+        else:
+            # noinspection PyProtectedMember
+            return parent._get_flag(flag)
+
+    def _format_and_raise(
+        self,
+        key: Any,
+        value: Any,
+        cause: Exception,
+        msg: Optional[str] = None,
+        type_override: Any = None,
+    ) -> None:
+        format_and_raise(
+            node=self,
+            key=key,
+            value=value,
+            msg=str(cause) if msg is None else msg,
+            cause=cause,
+            type_override=type_override,
+        )
+        assert False
+
+    @abstractmethod
+    def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str:
+        ...
+
+    def _dereference_node(self) -> "Node":
+        node = self._dereference_node_impl(throw_on_resolution_failure=True)
+        assert node is not None
+        return node
+
+    def _maybe_dereference_node(
+        self,
+        throw_on_resolution_failure: bool = False,
+        memo: Optional[Set[int]] = None,
+    ) -> Optional["Node"]:
+        return self._dereference_node_impl(
+            throw_on_resolution_failure=throw_on_resolution_failure,
+            memo=memo,
+        )
+
+    def _dereference_node_impl(
+        self,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]] = None,
+    ) -> Optional["Node"]:
+        if not self._is_interpolation():
+            return self
+
+        parent = self._get_parent_container()
+        if parent is None:
+            if throw_on_resolution_failure:
+                raise InterpolationResolutionError(
+                    "Cannot resolve interpolation for a node without a parent"
+                )
+            return None
+        assert parent is not None
+        key = self._key()
+        return parent._resolve_interpolation_from_parse_tree(
+            parent=parent,
+            key=key,
+            value=self,
+            parse_tree=parse(_get_value(self)),
+            throw_on_resolution_failure=throw_on_resolution_failure,
+            memo=memo,
+        )
+
+    def _get_root(self) -> "Container":
+        root: Optional[Box] = self._get_parent()
+        if root is None:
+            assert isinstance(self, Container)
+            return self
+        assert root is not None and isinstance(root, Box)
+        while root._get_parent() is not None:
+            root = root._get_parent()
+            assert root is not None and isinstance(root, Box)
+        assert root is not None and isinstance(root, Container)
+        return root
+
+    def _is_missing(self) -> bool:
+        """
+        Check if the node's value is `???` (does *not* resolve interpolations).
+        """
+        return _is_missing_value(self)
+
+    def _is_none(self) -> bool:
+        """
+        Check if the node's value is `None` (does *not* resolve interpolations).
+        """
+        return self._value() is None
+
+    @abstractmethod
+    def __eq__(self, other: Any) -> bool:
+        ...
+
+    @abstractmethod
+    def __ne__(self, other: Any) -> bool:
+        ...
+
+    @abstractmethod
+    def __hash__(self) -> int:
+        ...
+
+    @abstractmethod
+    def _value(self) -> Any:
+        ...
+
+    @abstractmethod
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        ...
+
+    @abstractmethod
+    def _is_optional(self) -> bool:
+        ...
+
+    @abstractmethod
+    def _is_interpolation(self) -> bool:
+        ...
+
+    def _key(self) -> Any:
+        return self._metadata.key
+
+    def _set_key(self, key: Any) -> None:
+        self._metadata.key = key
+
+    def _is_flags_root(self) -> bool:
+        return self._metadata.flags_root
+
+    def _set_flags_root(self, flags_root: bool) -> None:
+        if self._metadata.flags_root != flags_root:
+            self._metadata.flags_root = flags_root
+            self._invalidate_flags_cache()
+
+    def _has_ref_type(self) -> bool:
+        return self._metadata.ref_type is not Any
+
+
+class Box(Node):
+    """
+    Base class for nodes that can contain other nodes.
+    Concrete subclasses include DictConfig, ListConfig, and UnionNode.
+    """
+
+    _content: Any
+
+    def __init__(self, parent: Optional["Box"], metadata: Metadata):
+        super().__init__(parent=parent, metadata=metadata)
+        self.__dict__["_content"] = None
+
+    def __copy__(self) -> Any:
+        # real shallow copy is impossible because of the reference to the parent.
+        return copy.deepcopy(self)
+
+    def _re_parent(self) -> None:
+        from .dictconfig import DictConfig
+        from .listconfig import ListConfig
+
+        # update parents of first level Config nodes to self
+
+        if isinstance(self, DictConfig):
+            content = self.__dict__["_content"]
+            if isinstance(content, dict):
+                for _key, value in self.__dict__["_content"].items():
+                    if value is not None:
+                        value._set_parent(self)
+                    if isinstance(value, Box):
+                        value._re_parent()
+        elif isinstance(self, ListConfig):
+            content = self.__dict__["_content"]
+            if isinstance(content, list):
+                for item in self.__dict__["_content"]:
+                    if item is not None:
+                        item._set_parent(self)
+                    if isinstance(item, Box):
+                        item._re_parent()
+        elif isinstance(self, UnionNode):
+            content = self.__dict__["_content"]
+            if isinstance(content, Node):
+                content._set_parent(self)
+                if isinstance(content, Box):  # pragma: no cover
+                    # No coverage here as support for containers inside
+                    # UnionNode is not yet implemented
+                    content._re_parent()
+
+
+class Container(Box):
+    """
+    Container tagging interface
+    """
+
+    _metadata: ContainerMetadata
+
+    @abstractmethod
+    def _get_child(
+        self,
+        key: Any,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        ...
+
+    @abstractmethod
+    def _get_node(
+        self,
+        key: Any,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        ...
+
+    @abstractmethod
+    def __delitem__(self, key: Any) -> None:
+        ...
+
+    @abstractmethod
+    def __setitem__(self, key: Any, value: Any) -> None:
+        ...
+
+    @abstractmethod
+    def __iter__(self) -> Iterator[Any]:
+        ...
+
+    @abstractmethod
+    def __getitem__(self, key_or_index: Any) -> Any:
+        ...
+
+    def _resolve_key_and_root(self, key: str) -> Tuple["Container", str]:
+        orig = key
+        if not key.startswith("."):
+            return self._get_root(), key
+        else:
+            root: Optional[Container] = self
+            assert key.startswith(".")
+            while True:
+                assert root is not None
+                key = key[1:]
+                if not key.startswith("."):
+                    break
+                root = root._get_parent_container()
+                if root is None:
+                    raise ConfigKeyError(f"Error resolving key '{orig}'")
+
+            return root, key
+
+    def _select_impl(
+        self,
+        key: str,
+        throw_on_missing: bool,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]] = None,
+    ) -> Tuple[Optional["Container"], Optional[str], Optional[Node]]:
+        """
+        Select a value using dot separated key sequence
+        """
+        from .omegaconf import _select_one
+
+        if key == "":
+            return self, "", self
+
+        split = split_key(key)
+        root: Optional[Container] = self
+        for i in range(len(split) - 1):
+            if root is None:
+                break
+
+            k = split[i]
+            ret, _ = _select_one(
+                c=root,
+                key=k,
+                throw_on_missing=throw_on_missing,
+                throw_on_type_error=throw_on_resolution_failure,
+            )
+            if isinstance(ret, Node):
+                ret = ret._maybe_dereference_node(
+                    throw_on_resolution_failure=throw_on_resolution_failure,
+                    memo=memo,
+                )
+
+            if ret is not None and not isinstance(ret, Container):
+                parent_key = ".".join(split[0 : i + 1])
+                child_key = split[i + 1]
+                raise ConfigTypeError(
+                    f"Error trying to access {key}: node `{parent_key}` "
+                    f"is not a container and thus cannot contain `{child_key}`"
+                )
+            root = ret
+
+        if root is None:
+            return None, None, None
+
+        last_key = split[-1]
+        value, _ = _select_one(
+            c=root,
+            key=last_key,
+            throw_on_missing=throw_on_missing,
+            throw_on_type_error=throw_on_resolution_failure,
+        )
+        if value is None:
+            return root, last_key, None
+
+        if memo is not None:
+            vid = id(value)
+            if vid in memo:
+                raise InterpolationResolutionError("Recursive interpolation detected")
+            # push to memo "stack"
+            memo.add(vid)
+
+        try:
+            value = root._maybe_resolve_interpolation(
+                parent=root,
+                key=last_key,
+                value=value,
+                throw_on_resolution_failure=throw_on_resolution_failure,
+                memo=memo,
+            )
+        finally:
+            if memo is not None:
+                # pop from memo "stack"
+                memo.remove(vid)
+
+        return root, last_key, value
+
+    def _resolve_interpolation_from_parse_tree(
+        self,
+        parent: Optional["Container"],
+        value: "Node",
+        key: Any,
+        parse_tree: OmegaConfGrammarParser.ConfigValueContext,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]],
+    ) -> Optional["Node"]:
+        """
+        Resolve an interpolation.
+
+        This happens in two steps:
+            1. The parse tree is visited, which outputs either a `Node` (e.g.,
+               for node interpolations "${foo}"), a string (e.g., for string
+               interpolations "hello ${name}", or any other arbitrary value
+               (e.g., or custom interpolations "${foo:bar}").
+            2. This output is potentially validated and converted when the node
+               being resolved (`value`) is typed.
+
+        If an error occurs in one of the above steps, an `InterpolationResolutionError`
+        (or a subclass of it) is raised, *unless* `throw_on_resolution_failure` is set
+        to `False` (in which case the return value is `None`).
+
+        :param parent: Parent of the node being resolved.
+        :param value: Node being resolved.
+        :param key: The associated key in the parent.
+        :param parse_tree: The parse tree as obtained from `grammar_parser.parse()`.
+        :param throw_on_resolution_failure: If `False`, then exceptions raised during
+            the resolution of the interpolation are silenced, and instead `None` is
+            returned.
+
+        :return: A `Node` that contains the interpolation result. This may be an existing
+            node in the config (in the case of a node interpolation "${foo}"), or a new
+            node that is created to wrap the interpolated value. It is `None` if and only if
+            `throw_on_resolution_failure` is `False` and an error occurs during resolution.
+        """
+
+        try:
+            resolved = self.resolve_parse_tree(
+                parse_tree=parse_tree, node=value, key=key, memo=memo
+            )
+        except InterpolationResolutionError:
+            if throw_on_resolution_failure:
+                raise
+            return None
+
+        return self._validate_and_convert_interpolation_result(
+            parent=parent,
+            value=value,
+            key=key,
+            resolved=resolved,
+            throw_on_resolution_failure=throw_on_resolution_failure,
+        )
+
+    def _validate_and_convert_interpolation_result(
+        self,
+        parent: Optional["Container"],
+        value: "Node",
+        key: Any,
+        resolved: Any,
+        throw_on_resolution_failure: bool,
+    ) -> Optional["Node"]:
+        from .nodes import AnyNode, InterpolationResultNode, ValueNode
+
+        # If the output is not a Node already (e.g., because it is the output of a
+        # custom resolver), then we will need to wrap it within a Node.
+        must_wrap = not isinstance(resolved, Node)
+
+        # If the node is typed, validate (and possibly convert) the result.
+        if isinstance(value, ValueNode) and not isinstance(value, AnyNode):
+            res_value = _get_value(resolved)
+            try:
+                conv_value = value.validate_and_convert(res_value)
+            except ValidationError as e:
+                if throw_on_resolution_failure:
+                    self._format_and_raise(
+                        key=key,
+                        value=res_value,
+                        cause=e,
+                        msg=f"While dereferencing interpolation '{value}': {e}",
+                        type_override=InterpolationValidationError,
+                    )
+                return None
+
+            # If the converted value is of the same type, it means that no conversion
+            # was actually needed. As a result, we can keep the original `resolved`
+            # (and otherwise, the converted value must be wrapped into a new node).
+            if type(conv_value) != type(res_value):
+                must_wrap = True
+                resolved = conv_value
+
+        if must_wrap:
+            return InterpolationResultNode(value=resolved, key=key, parent=parent)
+        else:
+            assert isinstance(resolved, Node)
+            return resolved
+
+    def _validate_not_dereferencing_to_parent(self, node: Node, target: Node) -> None:
+        parent: Optional[Node] = node
+        while parent is not None:
+            if parent is target:
+                raise InterpolationResolutionError(
+                    "Interpolation to parent node detected"
+                )
+            parent = parent._get_parent()
+
+    def _resolve_node_interpolation(
+        self, inter_key: str, memo: Optional[Set[int]]
+    ) -> "Node":
+        """A node interpolation is of the form `${foo.bar}`"""
+        try:
+            root_node, inter_key = self._resolve_key_and_root(inter_key)
+        except ConfigKeyError as exc:
+            raise InterpolationKeyError(
+                f"ConfigKeyError while resolving interpolation: {exc}"
+            ).with_traceback(sys.exc_info()[2])
+
+        try:
+            parent, last_key, value = root_node._select_impl(
+                inter_key,
+                throw_on_missing=True,
+                throw_on_resolution_failure=True,
+                memo=memo,
+            )
+        except MissingMandatoryValue as exc:
+            raise InterpolationToMissingValueError(
+                f"MissingMandatoryValue while resolving interpolation: {exc}"
+            ).with_traceback(sys.exc_info()[2])
+
+        if parent is None or value is None:
+            raise InterpolationKeyError(f"Interpolation key '{inter_key}' not found")
+        else:
+            self._validate_not_dereferencing_to_parent(node=self, target=value)
+            return value
+
+    def _evaluate_custom_resolver(
+        self,
+        key: Any,
+        node: Node,
+        inter_type: str,
+        inter_args: Tuple[Any, ...],
+        inter_args_str: Tuple[str, ...],
+    ) -> Any:
+        from omegaconf import OmegaConf
+
+        resolver = OmegaConf._get_resolver(inter_type)
+        if resolver is not None:
+            root_node = self._get_root()
+            return resolver(
+                root_node,
+                self,
+                node,
+                inter_args,
+                inter_args_str,
+            )
+        else:
+            raise UnsupportedInterpolationType(
+                f"Unsupported interpolation type {inter_type}"
+            )
+
+    def _maybe_resolve_interpolation(
+        self,
+        parent: Optional["Container"],
+        key: Any,
+        value: Node,
+        throw_on_resolution_failure: bool,
+        memo: Optional[Set[int]] = None,
+    ) -> Optional[Node]:
+        value_kind = get_value_kind(value)
+        if value_kind != ValueKind.INTERPOLATION:
+            return value
+
+        parse_tree = parse(_get_value(value))
+        return self._resolve_interpolation_from_parse_tree(
+            parent=parent,
+            value=value,
+            key=key,
+            parse_tree=parse_tree,
+            throw_on_resolution_failure=throw_on_resolution_failure,
+            memo=memo if memo is not None else set(),
+        )
+
+    def resolve_parse_tree(
+        self,
+        parse_tree: ParserRuleContext,
+        node: Node,
+        memo: Optional[Set[int]] = None,
+        key: Optional[Any] = None,
+    ) -> Any:
+        """
+        Resolve a given parse tree into its value.
+
+        We make no assumption here on the type of the tree's root, so that the
+        return value may be of any type.
+        """
+
+        def node_interpolation_callback(
+            inter_key: str, memo: Optional[Set[int]]
+        ) -> Optional["Node"]:
+            return self._resolve_node_interpolation(inter_key=inter_key, memo=memo)
+
+        def resolver_interpolation_callback(
+            name: str, args: Tuple[Any, ...], args_str: Tuple[str, ...]
+        ) -> Any:
+            return self._evaluate_custom_resolver(
+                key=key,
+                node=node,
+                inter_type=name,
+                inter_args=args,
+                inter_args_str=args_str,
+            )
+
+        visitor = GrammarVisitor(
+            node_interpolation_callback=node_interpolation_callback,
+            resolver_interpolation_callback=resolver_interpolation_callback,
+            memo=memo,
+        )
+        try:
+            return visitor.visit(parse_tree)
+        except InterpolationResolutionError:
+            raise
+        except Exception as exc:
+            # Other kinds of exceptions are wrapped in an `InterpolationResolutionError`.
+            raise InterpolationResolutionError(
+                f"{type(exc).__name__} raised while resolving interpolation: {exc}"
+            ).with_traceback(sys.exc_info()[2])
+
+    def _invalidate_flags_cache(self) -> None:
+        from .dictconfig import DictConfig
+        from .listconfig import ListConfig
+
+        # invalidate subtree cache only if the cache is initialized in this node.
+
+        if self.__dict__["_flags_cache"] is not None:
+            self.__dict__["_flags_cache"] = None
+            if isinstance(self, DictConfig):
+                content = self.__dict__["_content"]
+                if isinstance(content, dict):
+                    for value in self.__dict__["_content"].values():
+                        value._invalidate_flags_cache()
+            elif isinstance(self, ListConfig):
+                content = self.__dict__["_content"]
+                if isinstance(content, list):
+                    for item in self.__dict__["_content"]:
+                        item._invalidate_flags_cache()
+
+
+class SCMode(Enum):
+    DICT = 1  # Convert to plain dict
+    DICT_CONFIG = 2  # Keep as OmegaConf DictConfig
+    INSTANTIATE = 3  # Create a dataclass or attrs class instance
+
+
+class UnionNode(Box):
+    """
+    This class handles Union type hints. The `_content` attribute is either a
+    child node that is compatible with the given Union ref_type, or it is a
+    special value (None or MISSING or interpolation).
+
+    Much of the logic for e.g. value assignment and type validation is
+    delegated to the child node. As such, UnionNode functions as a
+    "pass-through" node. User apps and downstream libraries should not need to
+    know about UnionNode (assuming they only use OmegaConf's public API).
+    """
+
+    _parent: Optional[Container]
+    _content: Union[Node, None, str]
+
+    def __init__(
+        self,
+        content: Any,
+        ref_type: Any,
+        is_optional: bool = True,
+        key: Any = None,
+        parent: Optional[Box] = None,
+    ) -> None:
+        try:
+            if not is_union_annotation(ref_type):  # pragma: no cover
+                msg = (
+                    f"UnionNode got unexpected ref_type {ref_type}. Please file a bug"
+                    + " report at https://github.com/omry/omegaconf/issues"
+                )
+                raise AssertionError(msg)
+            if not isinstance(parent, (Container, NoneType)):
+                raise ConfigTypeError("Parent type is not omegaconf.Container")
+            super().__init__(
+                parent=parent,
+                metadata=Metadata(
+                    ref_type=ref_type,
+                    object_type=None,
+                    optional=is_optional,
+                    key=key,
+                    flags={"convert": False},
+                ),
+            )
+            self._set_value(content)
+        except Exception as ex:
+            format_and_raise(node=None, key=key, value=content, msg=str(ex), cause=ex)
+
+    def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str:
+        parent = self._get_parent()
+        if parent is None:
+            if self._metadata.key is None:
+                return ""
+            else:
+                return str(self._metadata.key)
+        else:
+            return parent._get_full_key(self._metadata.key)
+
+    def __eq__(self, other: Any) -> bool:
+        content = self.__dict__["_content"]
+        if isinstance(content, Node):
+            ret = content.__eq__(other)
+        elif isinstance(other, Node):
+            ret = other.__eq__(content)
+        else:
+            ret = content.__eq__(other)
+        assert isinstance(ret, (bool, type(NotImplemented)))
+        return ret
+
+    def __ne__(self, other: Any) -> bool:
+        x = self.__eq__(other)
+        if x is NotImplemented:
+            return NotImplemented
+        return not x
+
+    def __hash__(self) -> int:
+        return hash(self.__dict__["_content"])
+
+    def _value(self) -> Union[Node, None, str]:
+        content = self.__dict__["_content"]
+        assert isinstance(content, (Node, NoneType, str))
+        return content
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        previous_content = self.__dict__["_content"]
+        previous_metadata = self.__dict__["_metadata"]
+        try:
+            self._set_value_impl(value, flags)
+        except Exception as e:
+            self.__dict__["_content"] = previous_content
+            self.__dict__["_metadata"] = previous_metadata
+            raise e
+
+    def _set_value_impl(
+        self, value: Any, flags: Optional[Dict[str, bool]] = None
+    ) -> None:
+        from omegaconf.omegaconf import _node_wrap
+
+        ref_type = self._metadata.ref_type
+        type_hint = self._metadata.type_hint
+
+        value = _get_value(value)
+        if _is_special(value):
+            assert isinstance(value, (str, NoneType))
+            if value is None:
+                if not self._is_optional():
+                    raise ValidationError(
+                        f"Value '$VALUE' is incompatible with type hint '{type_str(type_hint)}'"
+                    )
+            self.__dict__["_content"] = value
+        elif isinstance(value, Container):
+            raise ValidationError(
+                f"Cannot assign container '$VALUE' of type '$VALUE_TYPE' to {type_str(type_hint)}"
+            )
+        else:
+            for candidate_ref_type in ref_type.__args__:
+                try:
+                    self.__dict__["_content"] = _node_wrap(
+                        value=value,
+                        ref_type=candidate_ref_type,
+                        is_optional=False,
+                        key=None,
+                        parent=self,
+                    )
+                    break
+                except ValidationError:
+                    continue
+            else:
+                raise ValidationError(
+                    f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_str(type_hint)}'"
+                )
+
+    def _is_optional(self) -> bool:
+        return self.__dict__["_metadata"].optional is True
+
+    def _is_interpolation(self) -> bool:
+        return _is_interpolation(self.__dict__["_content"])
+
+    def __str__(self) -> str:
+        return str(self.__dict__["_content"])
+
+    def __repr__(self) -> str:
+        return repr(self.__dict__["_content"])
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "UnionNode":
+        res = object.__new__(type(self))
+        for key, value in self.__dict__.items():
+            if key not in ("_content", "_parent"):
+                res.__dict__[key] = copy.deepcopy(value, memo=memo)
+
+        src_content = self.__dict__["_content"]
+        if isinstance(src_content, Node):
+            old_parent = src_content.__dict__["_parent"]
+            try:
+                src_content.__dict__["_parent"] = None
+                content_copy = copy.deepcopy(src_content, memo=memo)
+                content_copy.__dict__["_parent"] = res
+            finally:
+                src_content.__dict__["_parent"] = old_parent
+        else:
+            # None and strings can be assigned as is
+            content_copy = src_content
+
+        res.__dict__["_content"] = content_copy
+        res.__dict__["_parent"] = self.__dict__["_parent"]
+        return res

mantis_evalkit/lib/python3.10/site-packages/omegaconf/basecontainer.py

@@ -0,0 +1,916 @@
+import copy
+import sys
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Tuple, Union
+
+import yaml
+
+from ._utils import (
+    _DEFAULT_MARKER_,
+    ValueKind,
+    _ensure_container,
+    _get_value,
+    _is_interpolation,
+    _is_missing_value,
+    _is_none,
+    _is_special,
+    _resolve_optional,
+    get_structured_config_data,
+    get_type_hint,
+    get_value_kind,
+    get_yaml_loader,
+    is_container_annotation,
+    is_dict_annotation,
+    is_list_annotation,
+    is_primitive_dict,
+    is_primitive_type_annotation,
+    is_structured_config,
+    is_tuple_annotation,
+    is_union_annotation,
+)
+from .base import (
+    Box,
+    Container,
+    ContainerMetadata,
+    DictKeyType,
+    Node,
+    SCMode,
+    UnionNode,
+)
+from .errors import (
+    ConfigCycleDetectedException,
+    ConfigTypeError,
+    InterpolationResolutionError,
+    KeyValidationError,
+    MissingMandatoryValue,
+    OmegaConfBaseException,
+    ReadonlyConfigError,
+    ValidationError,
+)
+
+if TYPE_CHECKING:
+    from .dictconfig import DictConfig  # pragma: no cover
+
+
+class BaseContainer(Container, ABC):
+    _resolvers: ClassVar[Dict[str, Any]] = {}
+
+    def __init__(self, parent: Optional[Box], metadata: ContainerMetadata):
+        if not (parent is None or isinstance(parent, Box)):
+            raise ConfigTypeError("Parent type is not omegaconf.Box")
+        super().__init__(parent=parent, metadata=metadata)
+
+    def _get_child(
+        self,
+        key: Any,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Union[Optional[Node], List[Optional[Node]]]:
+        """Like _get_node, passing through to the nearest concrete Node."""
+        child = self._get_node(
+            key=key,
+            validate_access=validate_access,
+            validate_key=validate_key,
+            throw_on_missing_value=throw_on_missing_value,
+            throw_on_missing_key=throw_on_missing_key,
+        )
+        if isinstance(child, UnionNode) and not _is_special(child):
+            value = child._value()
+            assert isinstance(value, Node) and not isinstance(value, UnionNode)
+            child = value
+        return child
+
+    def _resolve_with_default(
+        self,
+        key: Union[DictKeyType, int],
+        value: Node,
+        default_value: Any = _DEFAULT_MARKER_,
+    ) -> Any:
+        """returns the value with the specified key, like obj.key and obj['key']"""
+        if _is_missing_value(value):
+            if default_value is not _DEFAULT_MARKER_:
+                return default_value
+            raise MissingMandatoryValue("Missing mandatory value: $FULL_KEY")
+
+        resolved_node = self._maybe_resolve_interpolation(
+            parent=self,
+            key=key,
+            value=value,
+            throw_on_resolution_failure=True,
+        )
+
+        return _get_value(resolved_node)
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __repr__(self) -> str:
+        if self.__dict__["_content"] is None:
+            return "None"
+        elif self._is_interpolation() or self._is_missing():
+            v = self.__dict__["_content"]
+            return f"'{v}'"
+        else:
+            return self.__dict__["_content"].__repr__()  # type: ignore
+
+    # Support pickle
+    def __getstate__(self) -> Dict[str, Any]:
+        dict_copy = copy.copy(self.__dict__)
+
+        # no need to serialize the flags cache, it can be re-constructed later
+        dict_copy.pop("_flags_cache", None)
+
+        dict_copy["_metadata"] = copy.copy(dict_copy["_metadata"])
+        ref_type = self._metadata.ref_type
+        if is_container_annotation(ref_type):
+            if is_dict_annotation(ref_type):
+                dict_copy["_metadata"].ref_type = Dict
+            elif is_list_annotation(ref_type):
+                dict_copy["_metadata"].ref_type = List
+            else:
+                assert False
+        if sys.version_info < (3, 7):  # pragma: no cover
+            element_type = self._metadata.element_type
+            if is_union_annotation(element_type):
+                raise OmegaConfBaseException(
+                    "Serializing structured configs with `Union` element type requires python >= 3.7"
+                )
+        return dict_copy
+
+    # Support pickle
+    def __setstate__(self, d: Dict[str, Any]) -> None:
+        from omegaconf import DictConfig
+        from omegaconf._utils import is_generic_dict, is_generic_list
+
+        if isinstance(self, DictConfig):
+            key_type = d["_metadata"].key_type
+
+            # backward compatibility to load OmegaConf 2.0 configs
+            if key_type is None:
+                key_type = Any
+                d["_metadata"].key_type = key_type
+
+        element_type = d["_metadata"].element_type
+
+        # backward compatibility to load OmegaConf 2.0 configs
+        if element_type is None:
+            element_type = Any
+            d["_metadata"].element_type = element_type
+
+        ref_type = d["_metadata"].ref_type
+        if is_container_annotation(ref_type):
+            if is_generic_dict(ref_type):
+                d["_metadata"].ref_type = Dict[key_type, element_type]  # type: ignore
+            elif is_generic_list(ref_type):
+                d["_metadata"].ref_type = List[element_type]  # type: ignore
+            else:
+                assert False
+
+        d["_flags_cache"] = None
+        self.__dict__.update(d)
+
+    @abstractmethod
+    def __delitem__(self, key: Any) -> None:
+        ...
+
+    def __len__(self) -> int:
+        if self._is_none() or self._is_missing() or self._is_interpolation():
+            return 0
+        content = self.__dict__["_content"]
+        return len(content)
+
+    def merge_with_cli(self) -> None:
+        args_list = sys.argv[1:]
+        self.merge_with_dotlist(args_list)
+
+    def merge_with_dotlist(self, dotlist: List[str]) -> None:
+        from omegaconf import OmegaConf
+
+        def fail() -> None:
+            raise ValueError("Input list must be a list or a tuple of strings")
+
+        if not isinstance(dotlist, (list, tuple)):
+            fail()
+
+        for arg in dotlist:
+            if not isinstance(arg, str):
+                fail()
+
+            idx = arg.find("=")
+            if idx == -1:
+                key = arg
+                value = None
+            else:
+                key = arg[0:idx]
+                value = arg[idx + 1 :]
+                value = yaml.load(value, Loader=get_yaml_loader())
+
+            OmegaConf.update(self, key, value)
+
+    def is_empty(self) -> bool:
+        """return true if config is empty"""
+        return len(self.__dict__["_content"]) == 0
+
+    @staticmethod
+    def _to_content(
+        conf: Container,
+        resolve: bool,
+        throw_on_missing: bool,
+        enum_to_str: bool = False,
+        structured_config_mode: SCMode = SCMode.DICT,
+    ) -> Union[None, Any, str, Dict[DictKeyType, Any], List[Any]]:
+        from omegaconf import MISSING, DictConfig, ListConfig
+
+        def convert(val: Node) -> Any:
+            value = val._value()
+            if enum_to_str and isinstance(value, Enum):
+                value = f"{value.name}"
+
+            return value
+
+        def get_node_value(key: Union[DictKeyType, int]) -> Any:
+            try:
+                node = conf._get_child(key, throw_on_missing_value=throw_on_missing)
+            except MissingMandatoryValue as e:
+                conf._format_and_raise(key=key, value=None, cause=e)
+            assert isinstance(node, Node)
+            if resolve:
+                try:
+                    node = node._dereference_node()
+                except InterpolationResolutionError as e:
+                    conf._format_and_raise(key=key, value=None, cause=e)
+
+            if isinstance(node, Container):
+                value = BaseContainer._to_content(
+                    node,
+                    resolve=resolve,
+                    throw_on_missing=throw_on_missing,
+                    enum_to_str=enum_to_str,
+                    structured_config_mode=structured_config_mode,
+                )
+            else:
+                value = convert(node)
+            return value
+
+        if conf._is_none():
+            return None
+        elif conf._is_missing():
+            if throw_on_missing:
+                conf._format_and_raise(
+                    key=None,
+                    value=None,
+                    cause=MissingMandatoryValue("Missing mandatory value"),
+                )
+            else:
+                return MISSING
+        elif not resolve and conf._is_interpolation():
+            inter = conf._value()
+            assert isinstance(inter, str)
+            return inter
+
+        if resolve:
+            _conf = conf._dereference_node()
+            assert isinstance(_conf, Container)
+            conf = _conf
+
+        if isinstance(conf, DictConfig):
+            if (
+                conf._metadata.object_type not in (dict, None)
+                and structured_config_mode == SCMode.DICT_CONFIG
+            ):
+                return conf
+            if structured_config_mode == SCMode.INSTANTIATE and is_structured_config(
+                conf._metadata.object_type
+            ):
+                return conf._to_object()
+
+            retdict: Dict[DictKeyType, Any] = {}
+            for key in conf.keys():
+                value = get_node_value(key)
+                if enum_to_str and isinstance(key, Enum):
+                    key = f"{key.name}"
+                retdict[key] = value
+            return retdict
+        elif isinstance(conf, ListConfig):
+            retlist: List[Any] = []
+            for index in range(len(conf)):
+                item = get_node_value(index)
+                retlist.append(item)
+
+            return retlist
+        assert False
+
+    @staticmethod
+    def _map_merge(dest: "BaseContainer", src: "BaseContainer") -> None:
+        """merge src into dest and return a new copy, does not modified input"""
+        from omegaconf import AnyNode, DictConfig, ValueNode
+
+        assert isinstance(dest, DictConfig)
+        assert isinstance(src, DictConfig)
+        src_type = src._metadata.object_type
+        src_ref_type = get_type_hint(src)
+        assert src_ref_type is not None
+
+        # If source DictConfig is:
+        #  - None => set the destination DictConfig to None
+        #  - an interpolation => set the destination DictConfig to be the same interpolation
+        if src._is_none() or src._is_interpolation():
+            dest._set_value(src._value())
+            _update_types(node=dest, ref_type=src_ref_type, object_type=src_type)
+            return
+
+        dest._validate_merge(value=src)
+
+        def expand(node: Container) -> None:
+            rt = node._metadata.ref_type
+            val: Any
+            if rt is not Any:
+                if is_dict_annotation(rt):
+                    val = {}
+                elif is_list_annotation(rt) or is_tuple_annotation(rt):
+                    val = []
+                else:
+                    val = rt
+            elif isinstance(node, DictConfig):
+                val = {}
+            else:
+                assert False
+
+            node._set_value(val)
+
+        if (
+            src._is_missing()
+            and not dest._is_missing()
+            and is_structured_config(src_ref_type)
+        ):
+            # Replace `src` with a prototype of its corresponding structured config
+            # whose fields are all missing (to avoid overwriting fields in `dest`).
+            assert src_type is None  # src missing, so src's object_type should be None
+            src_type = src_ref_type
+            src = _create_structured_with_missing_fields(
+                ref_type=src_ref_type, object_type=src_type
+            )
+
+        if (dest._is_interpolation() or dest._is_missing()) and not src._is_missing():
+            expand(dest)
+
+        src_items = list(src) if not src._is_missing() else []
+        for key in src_items:
+            src_node = src._get_node(key, validate_access=False)
+            dest_node = dest._get_node(key, validate_access=False)
+            assert isinstance(src_node, Node)
+            assert dest_node is None or isinstance(dest_node, Node)
+            src_value = _get_value(src_node)
+
+            src_vk = get_value_kind(src_node)
+            src_node_missing = src_vk is ValueKind.MANDATORY_MISSING
+
+            if isinstance(dest_node, DictConfig):
+                dest_node._validate_merge(value=src_node)
+
+            if (
+                isinstance(dest_node, Container)
+                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():
+                target_node = dest_node._maybe_dereference_node()
+                if isinstance(target_node, Container):
+                    dest[key] = target_node
+                    dest_node = dest._get_node(key)
+
+            is_optional, et = _resolve_optional(dest._metadata.element_type)
+            if dest_node is None and is_structured_config(et) and not src_node_missing:
+                # merging into a new node. Use element_type as a base
+                dest[key] = DictConfig(
+                    et, parent=dest, ref_type=et, is_optional=is_optional
+                )
+                dest_node = dest._get_node(key)
+
+            if dest_node is not None:
+                if isinstance(dest_node, BaseContainer):
+                    if isinstance(src_node, BaseContainer):
+                        dest_node._merge_with(src_node)
+                    elif not src_node_missing:
+                        dest.__setitem__(key, src_node)
+                else:
+                    if isinstance(src_node, BaseContainer):
+                        dest.__setitem__(key, src_node)
+                    else:
+                        assert isinstance(dest_node, (ValueNode, UnionNode))
+                        assert isinstance(src_node, (ValueNode, UnionNode))
+                        try:
+                            if isinstance(dest_node, AnyNode):
+                                if src_node_missing:
+                                    node = copy.copy(src_node)
+                                    # if src node is missing, use the value from the dest_node,
+                                    # but validate it against the type of the src node before assigment
+                                    node._set_value(dest_node._value())
+                                else:
+                                    node = src_node
+                                dest.__setitem__(key, node)
+                            else:
+                                if not src_node_missing:
+                                    dest_node._set_value(src_value)
+
+                        except (ValidationError, ReadonlyConfigError) as e:
+                            dest._format_and_raise(key=key, value=src_value, cause=e)
+            else:
+                from omegaconf import open_dict
+
+                if is_structured_config(src_type):
+                    # verified to be compatible above in _validate_merge
+                    with open_dict(dest):
+                        dest[key] = src._get_node(key)
+                else:
+                    dest[key] = src._get_node(key)
+
+        _update_types(node=dest, ref_type=src_ref_type, object_type=src_type)
+
+        # explicit flags on the source config are replacing the flag values in the destination
+        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)
+
+    @staticmethod
+    def _list_merge(dest: Any, src: Any) -> None:
+        from omegaconf import DictConfig, ListConfig, OmegaConf
+
+        assert isinstance(dest, ListConfig)
+        assert isinstance(src, ListConfig)
+
+        if src._is_none():
+            dest._set_value(None)
+        elif src._is_missing():
+            # do not change dest if src is MISSING.
+            if dest._metadata.element_type is Any:
+                dest._metadata.element_type = src._metadata.element_type
+        elif src._is_interpolation():
+            dest._set_value(src._value())
+        else:
+            temp_target = ListConfig(content=[], parent=dest._get_parent())
+            temp_target.__dict__["_metadata"] = copy.deepcopy(
+                dest.__dict__["_metadata"]
+            )
+            is_optional, et = _resolve_optional(dest._metadata.element_type)
+            if is_structured_config(et):
+                prototype = DictConfig(et, ref_type=et, is_optional=is_optional)
+                for item in src._iter_ex(resolve=False):
+                    if isinstance(item, DictConfig):
+                        item = OmegaConf.merge(prototype, item)
+                    temp_target.append(item)
+            else:
+                for item in src._iter_ex(resolve=False):
+                    temp_target.append(item)
+
+            dest.__dict__["_content"] = temp_target.__dict__["_content"]
+
+        # explicit flags on the source config are replacing the flag values in the destination
+        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[
+            "BaseContainer", Dict[str, Any], List[Any], Tuple[Any, ...], Any
+        ],
+    ) -> None:
+        try:
+            self._merge_with(*others)
+        except Exception as e:
+            self._format_and_raise(key=None, value=None, cause=e)
+
+    def _merge_with(
+        self,
+        *others: Union[
+            "BaseContainer", Dict[str, Any], List[Any], Tuple[Any, ...], Any
+        ],
+    ) -> None:
+        from .dictconfig import DictConfig
+        from .listconfig import ListConfig
+
+        """merge a list of other Config objects into this one, overriding as needed"""
+        for other in others:
+            if other is None:
+                raise ValueError("Cannot merge with a None config")
+
+            my_flags = {}
+            if self._get_flag("allow_objects") is True:
+                my_flags = {"allow_objects": True}
+            other = _ensure_container(other, flags=my_flags)
+
+            if isinstance(self, DictConfig) and isinstance(other, DictConfig):
+                BaseContainer._map_merge(self, other)
+            elif isinstance(self, ListConfig) and isinstance(other, ListConfig):
+                BaseContainer._list_merge(self, other)
+            else:
+                raise TypeError("Cannot merge DictConfig with ListConfig")
+
+        # recursively correct the parent hierarchy after the merge
+        self._re_parent()
+
+    # noinspection PyProtectedMember
+    def _set_item_impl(self, key: Any, value: Any) -> None:
+        """
+        Changes the value of the node key with the desired value. If the node key doesn't
+        exist it creates a new one.
+        """
+        from .nodes import AnyNode, ValueNode
+
+        if isinstance(value, Node):
+            do_deepcopy = not self._get_flag("no_deepcopy_set_nodes")
+            if not do_deepcopy and isinstance(value, Box):
+                # if value is from the same config, perform a deepcopy no matter what.
+                if self._get_root() is value._get_root():
+                    do_deepcopy = True
+
+            if do_deepcopy:
+                value = copy.deepcopy(value)
+            value._set_parent(None)
+
+            try:
+                old = value._key()
+                value._set_key(key)
+                self._validate_set(key, value)
+            finally:
+                value._set_key(old)
+        else:
+            self._validate_set(key, value)
+
+        if self._get_flag("readonly"):
+            raise ReadonlyConfigError("Cannot change read-only config container")
+
+        input_is_node = isinstance(value, Node)
+        target_node_ref = self._get_node(key)
+        assert target_node_ref is None or isinstance(target_node_ref, Node)
+
+        input_is_typed_vnode = isinstance(value, ValueNode) and not isinstance(
+            value, AnyNode
+        )
+
+        def get_target_type_hint(val: Any) -> Any:
+            if not is_structured_config(val):
+                type_hint = self._metadata.element_type
+            else:
+                target = self._get_node(key)
+                if target is None:
+                    type_hint = self._metadata.element_type
+                else:
+                    assert isinstance(target, Node)
+                    type_hint = target._metadata.type_hint
+            return type_hint
+
+        target_type_hint = get_target_type_hint(value)
+        _, target_ref_type = _resolve_optional(target_type_hint)
+
+        def assign(value_key: Any, val: Node) -> None:
+            assert val._get_parent() is None
+            v = val
+            v._set_parent(self)
+            v._set_key(value_key)
+            _deep_update_type_hint(node=v, type_hint=self._metadata.element_type)
+            self.__dict__["_content"][value_key] = v
+
+        if input_is_typed_vnode and not is_union_annotation(target_ref_type):
+            assign(key, value)
+        else:
+            # input is not a ValueNode, can be primitive or box
+
+            special_value = _is_special(value)
+            # We use the `Node._set_value` method if the target node exists and:
+            # 1. the target has an explicit ref_type, or
+            # 2. the target is an AnyNode and the input is a primitive type.
+            should_set_value = target_node_ref is not None and (
+                target_node_ref._has_ref_type()
+                or (
+                    isinstance(target_node_ref, AnyNode)
+                    and is_primitive_type_annotation(value)
+                )
+            )
+            if should_set_value:
+                if special_value and isinstance(value, Node):
+                    value = value._value()
+                self.__dict__["_content"][key]._set_value(value)
+            elif input_is_node:
+                if (
+                    special_value
+                    and (
+                        is_container_annotation(target_ref_type)
+                        or is_structured_config(target_ref_type)
+                    )
+                    or is_primitive_type_annotation(target_ref_type)
+                    or is_union_annotation(target_ref_type)
+                ):
+                    value = _get_value(value)
+                    self._wrap_value_and_set(key, value, target_type_hint)
+                else:
+                    assign(key, value)
+            else:
+                self._wrap_value_and_set(key, value, target_type_hint)
+
+    def _wrap_value_and_set(self, key: Any, val: Any, type_hint: Any) -> None:
+        from omegaconf.omegaconf import _maybe_wrap
+
+        is_optional, ref_type = _resolve_optional(type_hint)
+
+        try:
+            wrapped = _maybe_wrap(
+                ref_type=ref_type,
+                key=key,
+                value=val,
+                is_optional=is_optional,
+                parent=self,
+            )
+        except ValidationError as e:
+            self._format_and_raise(key=key, value=val, cause=e)
+        self.__dict__["_content"][key] = wrapped
+
+    @staticmethod
+    def _item_eq(
+        c1: Container,
+        k1: Union[DictKeyType, int],
+        c2: Container,
+        k2: Union[DictKeyType, int],
+    ) -> bool:
+        v1 = c1._get_child(k1)
+        v2 = c2._get_child(k2)
+        assert v1 is not None and v2 is not None
+
+        assert isinstance(v1, Node)
+        assert isinstance(v2, Node)
+
+        if v1._is_none() and v2._is_none():
+            return True
+
+        if v1._is_missing() and v2._is_missing():
+            return True
+
+        v1_inter = v1._is_interpolation()
+        v2_inter = v2._is_interpolation()
+        dv1: Optional[Node] = v1
+        dv2: Optional[Node] = v2
+
+        if v1_inter:
+            dv1 = v1._maybe_dereference_node()
+        if v2_inter:
+            dv2 = v2._maybe_dereference_node()
+
+        if v1_inter and v2_inter:
+            if dv1 is None or dv2 is None:
+                return v1 == v2
+            else:
+                # both are not none, if both are containers compare as container
+                if isinstance(dv1, Container) and isinstance(dv2, Container):
+                    if dv1 != dv2:
+                        return False
+                dv1 = _get_value(dv1)
+                dv2 = _get_value(dv2)
+                return dv1 == dv2
+        elif not v1_inter and not v2_inter:
+            v1 = _get_value(v1)
+            v2 = _get_value(v2)
+            ret = v1 == v2
+            assert isinstance(ret, bool)
+            return ret
+        else:
+            dv1 = _get_value(dv1)
+            dv2 = _get_value(dv2)
+            ret = dv1 == dv2
+            assert isinstance(ret, bool)
+            return ret
+
+    def _is_optional(self) -> bool:
+        return self.__dict__["_metadata"].optional is True
+
+    def _is_interpolation(self) -> bool:
+        return _is_interpolation(self.__dict__["_content"])
+
+    @abstractmethod
+    def _validate_get(self, key: Any, value: Any = None) -> None:
+        ...
+
+    @abstractmethod
+    def _validate_set(self, key: Any, value: Any) -> None:
+        ...
+
+    def _value(self) -> Any:
+        return self.__dict__["_content"]
+
+    def _get_full_key(self, key: Union[DictKeyType, int, slice, None]) -> str:
+        from .listconfig import ListConfig
+        from .omegaconf import _select_one
+
+        if not isinstance(key, (int, str, Enum, float, bool, slice, bytes, type(None))):
+            return ""
+
+        def _slice_to_str(x: slice) -> str:
+            if x.step is not None:
+                return f"{x.start}:{x.stop}:{x.step}"
+            else:
+                return f"{x.start}:{x.stop}"
+
+        def prepand(
+            full_key: str,
+            parent_type: Any,
+            cur_type: Any,
+            key: Optional[Union[DictKeyType, int, slice]],
+        ) -> str:
+            if key is None:
+                return full_key
+
+            if isinstance(key, slice):
+                key = _slice_to_str(key)
+            elif isinstance(key, Enum):
+                key = key.name
+            else:
+                key = str(key)
+
+            assert isinstance(key, str)
+
+            if issubclass(parent_type, ListConfig):
+                if full_key != "":
+                    if issubclass(cur_type, ListConfig):
+                        full_key = f"[{key}]{full_key}"
+                    else:
+                        full_key = f"[{key}].{full_key}"
+                else:
+                    full_key = f"[{key}]"
+            else:
+                if full_key == "":
+                    full_key = key
+                else:
+                    if issubclass(cur_type, ListConfig):
+                        full_key = f"{key}{full_key}"
+                    else:
+                        full_key = f"{key}.{full_key}"
+            return full_key
+
+        if key is not None and key != "":
+            assert isinstance(self, Container)
+            cur, _ = _select_one(
+                c=self, key=str(key), throw_on_missing=False, throw_on_type_error=False
+            )
+            if cur is None:
+                cur = self
+                full_key = prepand("", type(cur), None, key)
+                if cur._key() is not None:
+                    full_key = prepand(
+                        full_key, type(cur._get_parent()), type(cur), cur._key()
+                    )
+            else:
+                full_key = prepand("", type(cur._get_parent()), type(cur), cur._key())
+        else:
+            cur = self
+            if cur._key() is None:
+                return ""
+            full_key = self._key()
+
+        assert cur is not None
+        memo = {id(cur)}  # remember already visited nodes so as to detect cycles
+        while cur._get_parent() is not None:
+            cur = cur._get_parent()
+            if id(cur) in memo:
+                raise ConfigCycleDetectedException(
+                    f"Cycle when iterating over parents of key `{key!s}`"
+                )
+            memo.add(id(cur))
+            assert cur is not None
+            if cur._key() is not None:
+                full_key = prepand(
+                    full_key, type(cur._get_parent()), type(cur), cur._key()
+                )
+
+        return full_key
+
+
+def _create_structured_with_missing_fields(
+    ref_type: type, object_type: Optional[type] = None
+) -> "DictConfig":
+    from . import MISSING, DictConfig
+
+    cfg_data = get_structured_config_data(ref_type)
+    for v in cfg_data.values():
+        v._set_value(MISSING)
+
+    cfg = DictConfig(cfg_data)
+    cfg._metadata.optional, cfg._metadata.ref_type = _resolve_optional(ref_type)
+    cfg._metadata.object_type = object_type
+
+    return cfg
+
+
+def _update_types(node: Node, ref_type: Any, object_type: Optional[type]) -> None:
+    if object_type is not None and not is_primitive_dict(object_type):
+        node._metadata.object_type = object_type
+
+    if node._metadata.ref_type is Any:
+        _deep_update_type_hint(node, ref_type)
+
+
+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
+
+    from ._utils import get_dict_key_value_types, get_list_element_type
+
+    if type_hint is Any:
+        return
+
+    _shallow_validate_type_hint(node, type_hint)
+
+    new_is_optional, new_ref_type = _resolve_optional(type_hint)
+    node._metadata.ref_type = new_ref_type
+    node._metadata.optional = new_is_optional
+
+    if is_list_annotation(new_ref_type) and isinstance(node, ListConfig):
+        new_element_type = get_list_element_type(new_ref_type)
+        node._metadata.element_type = new_element_type
+        if not _is_special(node):
+            for i in range(len(node)):
+                _deep_update_subnode(node, i, new_element_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
+        node._metadata.element_type = new_element_type
+        if not _is_special(node):
+            for key in node:
+                if new_key_type is not Any and not isinstance(key, new_key_type):
+                    raise KeyValidationError(
+                        f"Key {key!r} ({type(key).__name__}) is incompatible"
+                        + f" with key type hint '{new_key_type.__name__}'"
+                    )
+                _deep_update_subnode(node, key, new_element_type)
+
+
+def _deep_update_subnode(node: BaseContainer, key: Any, value_type_hint: Any) -> None:
+    """Get node[key] and ensure it is compatible with value_type_hint, mutating if necessary."""
+    subnode = node._get_node(key)
+    assert isinstance(subnode, Node)
+    if _is_special(subnode):
+        # Ensure special values are wrapped in a Node subclass that
+        # is compatible with the type hint.
+        node._wrap_value_and_set(key, subnode._value(), value_type_hint)
+        subnode = node._get_node(key)
+        assert isinstance(subnode, Node)
+    _deep_update_type_hint(subnode, value_type_hint)
+
+
+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, ValueNode
+
+    is_optional, ref_type = _resolve_optional(type_hint)
+
+    vk = get_value_kind(node)
+
+    if node._is_none():
+        if not is_optional:
+            value = _get_value(node)
+            raise ValidationError(
+                f"Value {value!r} ({type(value).__name__})"
+                + f" is incompatible with type hint '{ref_type.__name__}'"
+            )
+        return
+    elif vk in (ValueKind.MANDATORY_MISSING, ValueKind.INTERPOLATION):
+        return
+    elif vk == ValueKind.VALUE:
+        if is_primitive_type_annotation(ref_type) and isinstance(node, ValueNode):
+            value = node._value()
+            if not isinstance(value, ref_type):
+                raise ValidationError(
+                    f"Value {value!r} ({type(value).__name__})"
+                    + f" is incompatible with type hint '{ref_type.__name__}'"
+                )
+        elif is_structured_config(ref_type) and isinstance(node, DictConfig):
+            return
+        elif is_dict_annotation(ref_type) and isinstance(node, DictConfig):
+            return
+        elif is_list_annotation(ref_type) and isinstance(node, ListConfig):
+            return
+        else:
+            if isinstance(node, ValueNode):
+                value = node._value()
+                raise ValidationError(
+                    f"Value {value!r} ({type(value).__name__})"
+                    + f" is incompatible with type hint '{ref_type}'"
+                )
+            else:
+                raise ValidationError(
+                    f"'{type(node).__name__}' is incompatible"
+                    + f" with type hint '{ref_type}'"
+                )
+
+    else:
+        assert False

mantis_evalkit/lib/python3.10/site-packages/omegaconf/dictconfig.py

@@ -0,0 +1,776 @@
+import copy
+from enum import Enum
+from typing import (
+    Any,
+    Dict,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    List,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
+
+from ._utils import (
+    _DEFAULT_MARKER_,
+    ValueKind,
+    _get_value,
+    _is_interpolation,
+    _is_missing_literal,
+    _is_missing_value,
+    _is_none,
+    _resolve_optional,
+    _valid_dict_key_annotation_type,
+    format_and_raise,
+    get_structured_config_data,
+    get_structured_config_init_field_names,
+    get_type_of,
+    get_value_kind,
+    is_container_annotation,
+    is_dict,
+    is_primitive_dict,
+    is_structured_config,
+    is_structured_config_frozen,
+    type_str,
+)
+from .base import Box, Container, ContainerMetadata, DictKeyType, Node
+from .basecontainer import BaseContainer
+from .errors import (
+    ConfigAttributeError,
+    ConfigKeyError,
+    ConfigTypeError,
+    InterpolationResolutionError,
+    KeyValidationError,
+    MissingMandatoryValue,
+    OmegaConfBaseException,
+    ReadonlyConfigError,
+    ValidationError,
+)
+from .nodes import EnumNode, ValueNode
+
+
+class DictConfig(BaseContainer, MutableMapping[Any, Any]):
+
+    _metadata: ContainerMetadata
+    _content: Union[Dict[DictKeyType, Node], None, str]
+
+    def __init__(
+        self,
+        content: Union[Dict[DictKeyType, Any], "DictConfig", Any],
+        key: Any = None,
+        parent: Optional[Box] = None,
+        ref_type: Union[Any, Type[Any]] = Any,
+        key_type: Union[Any, Type[Any]] = Any,
+        element_type: Union[Any, Type[Any]] = Any,
+        is_optional: bool = True,
+        flags: Optional[Dict[str, bool]] = None,
+    ) -> None:
+        try:
+            if isinstance(content, DictConfig):
+                if flags is None:
+                    flags = content._metadata.flags
+            super().__init__(
+                parent=parent,
+                metadata=ContainerMetadata(
+                    key=key,
+                    optional=is_optional,
+                    ref_type=ref_type,
+                    object_type=dict,
+                    key_type=key_type,
+                    element_type=element_type,
+                    flags=flags,
+                ),
+            )
+
+            if not _valid_dict_key_annotation_type(key_type):
+                raise KeyValidationError(f"Unsupported key type {key_type}")
+
+            if is_structured_config(content) or is_structured_config(ref_type):
+                self._set_value(content, flags=flags)
+                if is_structured_config_frozen(content) or is_structured_config_frozen(
+                    ref_type
+                ):
+                    self._set_flag("readonly", True)
+
+            else:
+                if isinstance(content, DictConfig):
+                    metadata = copy.deepcopy(content._metadata)
+                    metadata.key = key
+                    metadata.ref_type = ref_type
+                    metadata.optional = is_optional
+                    metadata.element_type = element_type
+                    metadata.key_type = key_type
+                    self.__dict__["_metadata"] = metadata
+                self._set_value(content, flags=flags)
+        except Exception as ex:
+            format_and_raise(node=None, key=key, value=None, cause=ex, msg=str(ex))
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> "DictConfig":
+        res = DictConfig(None)
+        res.__dict__["_metadata"] = copy.deepcopy(self.__dict__["_metadata"], memo=memo)
+        res.__dict__["_flags_cache"] = copy.deepcopy(
+            self.__dict__["_flags_cache"], memo=memo
+        )
+
+        src_content = self.__dict__["_content"]
+        if isinstance(src_content, dict):
+            content_copy = {}
+            for k, v in src_content.items():
+                old_parent = v.__dict__["_parent"]
+                try:
+                    v.__dict__["_parent"] = None
+                    vc = copy.deepcopy(v, memo=memo)
+                    vc.__dict__["_parent"] = res
+                    content_copy[k] = vc
+                finally:
+                    v.__dict__["_parent"] = old_parent
+        else:
+            # None and strings can be assigned as is
+            content_copy = src_content
+
+        res.__dict__["_content"] = content_copy
+        # parent is retained, but not copied
+        res.__dict__["_parent"] = self.__dict__["_parent"]
+        return res
+
+    def copy(self) -> "DictConfig":
+        return copy.copy(self)
+
+    def _is_typed(self) -> bool:
+        return self._metadata.object_type not in (Any, None) and not is_dict(
+            self._metadata.object_type
+        )
+
+    def _validate_get(self, key: Any, value: Any = None) -> None:
+        is_typed = self._is_typed()
+
+        is_struct = self._get_flag("struct") is True
+        if key not in self.__dict__["_content"]:
+            if is_typed:
+                # do not raise an exception if struct is explicitly set to False
+                if self._get_node_flag("struct") is False:
+                    return
+            if is_typed or is_struct:
+                if is_typed:
+                    assert self._metadata.object_type not in (dict, None)
+                    msg = f"Key '{key}' not in '{self._metadata.object_type.__name__}'"
+                else:
+                    msg = f"Key '{key}' is not in struct"
+                self._format_and_raise(
+                    key=key, value=value, cause=ConfigAttributeError(msg)
+                )
+
+    def _validate_set(self, key: Any, value: Any) -> None:
+        from omegaconf import OmegaConf
+
+        vk = get_value_kind(value)
+        if vk == ValueKind.INTERPOLATION:
+            return
+        if _is_none(value):
+            self._validate_non_optional(key, value)
+            return
+        if vk == ValueKind.MANDATORY_MISSING or value is None:
+            return
+
+        target = self._get_node(key) if key is not None else self
+
+        target_has_ref_type = isinstance(
+            target, DictConfig
+        ) and target._metadata.ref_type not in (Any, dict)
+        is_valid_target = target is None or not target_has_ref_type
+
+        if is_valid_target:
+            return
+
+        assert isinstance(target, Node)
+
+        target_type = target._metadata.ref_type
+        value_type = OmegaConf.get_type(value)
+
+        if is_dict(value_type) and is_dict(target_type):
+            return
+        if is_container_annotation(target_type) and not is_container_annotation(
+            value_type
+        ):
+            raise ValidationError(
+                f"Cannot assign {type_str(value_type)} to {type_str(target_type)}"
+            )
+
+        if target_type is not None and value_type is not None:
+            origin = getattr(target_type, "__origin__", target_type)
+            if not issubclass(value_type, origin):
+                self._raise_invalid_value(value, value_type, target_type)
+
+    def _validate_merge(self, value: Any) -> None:
+        from omegaconf import OmegaConf
+
+        dest = self
+        src = value
+
+        self._validate_non_optional(None, src)
+
+        dest_obj_type = OmegaConf.get_type(dest)
+        src_obj_type = OmegaConf.get_type(src)
+
+        if dest._is_missing() and src._metadata.object_type not in (dict, None):
+            self._validate_set(key=None, value=_get_value(src))
+
+        if src._is_missing():
+            return
+
+        validation_error = (
+            dest_obj_type is not None
+            and src_obj_type is not None
+            and is_structured_config(dest_obj_type)
+            and not src._is_none()
+            and not is_dict(src_obj_type)
+            and not issubclass(src_obj_type, dest_obj_type)
+        )
+        if validation_error:
+            msg = (
+                f"Merge error: {type_str(src_obj_type)} is not a "
+                f"subclass of {type_str(dest_obj_type)}. value: {src}"
+            )
+            raise ValidationError(msg)
+
+    def _validate_non_optional(self, key: Optional[DictKeyType], value: Any) -> None:
+        if _is_none(value, resolve=True, throw_on_resolution_failure=False):
+
+            if key is not None:
+                child = self._get_node(key)
+                if child is not None:
+                    assert isinstance(child, Node)
+                    field_is_optional = child._is_optional()
+                else:
+                    field_is_optional, _ = _resolve_optional(
+                        self._metadata.element_type
+                    )
+            else:
+                field_is_optional = self._is_optional()
+
+            if not field_is_optional:
+                self._format_and_raise(
+                    key=key,
+                    value=value,
+                    cause=ValidationError("field '$FULL_KEY' is not Optional"),
+                )
+
+    def _raise_invalid_value(
+        self, value: Any, value_type: Any, target_type: Any
+    ) -> None:
+        assert value_type is not None
+        assert target_type is not None
+        msg = (
+            f"Invalid type assigned: {type_str(value_type)} is not a "
+            f"subclass of {type_str(target_type)}. value: {value}"
+        )
+        raise ValidationError(msg)
+
+    def _validate_and_normalize_key(self, key: Any) -> DictKeyType:
+        return self._s_validate_and_normalize_key(self._metadata.key_type, key)
+
+    def _s_validate_and_normalize_key(self, key_type: Any, key: Any) -> DictKeyType:
+        if key_type is Any:
+            for t in DictKeyType.__args__:  # type: ignore
+                if isinstance(key, t):
+                    return key  # type: ignore
+            raise KeyValidationError("Incompatible key type '$KEY_TYPE'")
+        elif key_type is bool and key in [0, 1]:
+            # Python treats True as 1 and False as 0 when used as dict keys
+            #   assert hash(0) == hash(False)
+            #   assert hash(1) == hash(True)
+            return bool(key)
+        elif key_type in (str, bytes, int, float, bool):  # primitive type
+            if not isinstance(key, key_type):
+                raise KeyValidationError(
+                    f"Key $KEY ($KEY_TYPE) is incompatible with ({key_type.__name__})"
+                )
+
+            return key  # type: ignore
+        elif issubclass(key_type, Enum):
+            try:
+                return EnumNode.validate_and_convert_to_enum(key_type, key)
+            except ValidationError:
+                valid = ", ".join([x for x in key_type.__members__.keys()])
+                raise KeyValidationError(
+                    f"Key '$KEY' is incompatible with the enum type '{key_type.__name__}', valid: [{valid}]"
+                )
+        else:
+            assert False, f"Unsupported key type {key_type}"
+
+    def __setitem__(self, key: DictKeyType, value: Any) -> None:
+        try:
+            self.__set_impl(key=key, value=value)
+        except AttributeError as e:
+            self._format_and_raise(
+                key=key, value=value, type_override=ConfigKeyError, cause=e
+            )
+        except Exception as e:
+            self._format_and_raise(key=key, value=value, cause=e)
+
+    def __set_impl(self, key: DictKeyType, value: Any) -> None:
+        key = self._validate_and_normalize_key(key)
+        self._set_item_impl(key, value)
+
+    # hide content while inspecting in debugger
+    def __dir__(self) -> Iterable[str]:
+        if self._is_missing() or self._is_none():
+            return []
+        return self.__dict__["_content"].keys()  # type: ignore
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        Allow assigning attributes to DictConfig
+        :param key:
+        :param value:
+        :return:
+        """
+        try:
+            self.__set_impl(key, value)
+        except Exception as e:
+            if isinstance(e, OmegaConfBaseException) and e._initialized:
+                raise e
+            self._format_and_raise(key=key, value=value, cause=e)
+            assert False
+
+    def __getattr__(self, key: str) -> Any:
+        """
+        Allow accessing dictionary values as attributes
+        :param key:
+        :return:
+        """
+        if key == "__name__":
+            raise AttributeError()
+
+        try:
+            return self._get_impl(
+                key=key, default_value=_DEFAULT_MARKER_, validate_key=False
+            )
+        except ConfigKeyError as e:
+            self._format_and_raise(
+                key=key, value=None, cause=e, type_override=ConfigAttributeError
+            )
+        except Exception as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def __getitem__(self, key: DictKeyType) -> Any:
+        """
+        Allow map style access
+        :param key:
+        :return:
+        """
+
+        try:
+            return self._get_impl(key=key, default_value=_DEFAULT_MARKER_)
+        except AttributeError as e:
+            self._format_and_raise(
+                key=key, value=None, cause=e, type_override=ConfigKeyError
+            )
+        except Exception as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def __delattr__(self, key: str) -> None:
+        """
+        Allow deleting dictionary values as attributes
+        :param key:
+        :return:
+        """
+        if self._get_flag("readonly"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ReadonlyConfigError(
+                    "DictConfig in read-only mode does not support deletion"
+                ),
+            )
+        try:
+            del self.__dict__["_content"][key]
+        except KeyError:
+            msg = "Attribute not found: '$KEY'"
+            self._format_and_raise(key=key, value=None, cause=ConfigAttributeError(msg))
+
+    def __delitem__(self, key: DictKeyType) -> None:
+        key = self._validate_and_normalize_key(key)
+        if self._get_flag("readonly"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ReadonlyConfigError(
+                    "DictConfig in read-only mode does not support deletion"
+                ),
+            )
+        if self._get_flag("struct"):
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ConfigTypeError(
+                    "DictConfig in struct mode does not support deletion"
+                ),
+            )
+        if self._is_typed() and self._get_node_flag("struct") is not False:
+            self._format_and_raise(
+                key=key,
+                value=None,
+                cause=ConfigTypeError(
+                    f"{type_str(self._metadata.object_type)} (DictConfig) does not support deletion"
+                ),
+            )
+
+        try:
+            del self.__dict__["_content"][key]
+        except KeyError:
+            msg = "Key not found: '$KEY'"
+            self._format_and_raise(key=key, value=None, cause=ConfigKeyError(msg))
+
+    def get(self, key: DictKeyType, default_value: Any = None) -> Any:
+        """Return the value for `key` if `key` is in the dictionary, else
+        `default_value` (defaulting to `None`)."""
+        try:
+            return self._get_impl(key=key, default_value=default_value)
+        except KeyValidationError as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def _get_impl(
+        self, key: DictKeyType, default_value: Any, validate_key: bool = True
+    ) -> Any:
+        try:
+            node = self._get_child(
+                key=key, throw_on_missing_key=True, validate_key=validate_key
+            )
+        except (ConfigAttributeError, ConfigKeyError):
+            if default_value is not _DEFAULT_MARKER_:
+                return default_value
+            else:
+                raise
+        assert isinstance(node, Node)
+        return self._resolve_with_default(
+            key=key, value=node, default_value=default_value
+        )
+
+    def _get_node(
+        self,
+        key: DictKeyType,
+        validate_access: bool = True,
+        validate_key: bool = True,
+        throw_on_missing_value: bool = False,
+        throw_on_missing_key: bool = False,
+    ) -> Optional[Node]:
+        try:
+            key = self._validate_and_normalize_key(key)
+        except KeyValidationError:
+            if validate_access and validate_key:
+                raise
+            else:
+                if throw_on_missing_key:
+                    raise ConfigAttributeError
+                else:
+                    return None
+
+        if validate_access:
+            self._validate_get(key)
+
+        value: Optional[Node] = self.__dict__["_content"].get(key)
+        if value is None:
+            if throw_on_missing_key:
+                raise ConfigKeyError(f"Missing key {key!s}")
+        elif throw_on_missing_value and value._is_missing():
+            raise MissingMandatoryValue("Missing mandatory value: $KEY")
+        return value
+
+    def pop(self, key: DictKeyType, default: Any = _DEFAULT_MARKER_) -> Any:
+        try:
+            if self._get_flag("readonly"):
+                raise ReadonlyConfigError("Cannot pop from read-only node")
+            if self._get_flag("struct"):
+                raise ConfigTypeError("DictConfig in struct mode does not support pop")
+            if self._is_typed() and self._get_node_flag("struct") is not False:
+                raise ConfigTypeError(
+                    f"{type_str(self._metadata.object_type)} (DictConfig) does not support pop"
+                )
+            key = self._validate_and_normalize_key(key)
+            node = self._get_child(key=key, validate_access=False)
+            if node is not None:
+                assert isinstance(node, Node)
+                value = self._resolve_with_default(
+                    key=key, value=node, default_value=default
+                )
+
+                del self[key]
+                return value
+            else:
+                if default is not _DEFAULT_MARKER_:
+                    return default
+                else:
+                    full = self._get_full_key(key=key)
+                    if full != key:
+                        raise ConfigKeyError(
+                            f"Key not found: '{key!s}' (path: '{full}')"
+                        )
+                    else:
+                        raise ConfigKeyError(f"Key not found: '{key!s}'")
+        except Exception as e:
+            self._format_and_raise(key=key, value=None, cause=e)
+
+    def keys(self) -> KeysView[DictKeyType]:
+        if self._is_missing() or self._is_interpolation() or self._is_none():
+            return {}.keys()
+        ret = self.__dict__["_content"].keys()
+        assert isinstance(ret, KeysView)
+        return ret
+
+    def __contains__(self, key: object) -> bool:
+        """
+        A key is contained in a DictConfig if there is an associated value and
+        it is not a mandatory missing value ('???').
+        :param key:
+        :return:
+        """
+
+        try:
+            key = self._validate_and_normalize_key(key)
+        except KeyValidationError:
+            return False
+
+        try:
+            node = self._get_child(key)
+            assert node is None or isinstance(node, Node)
+        except (KeyError, AttributeError):
+            node = None
+
+        if node is None:
+            return False
+        else:
+            try:
+                self._resolve_with_default(key=key, value=node)
+                return True
+            except InterpolationResolutionError:
+                # Interpolations that fail count as existing.
+                return True
+            except MissingMandatoryValue:
+                # Missing values count as *not* existing.
+                return False
+
+    def __iter__(self) -> Iterator[DictKeyType]:
+        return iter(self.keys())
+
+    def items(self) -> ItemsView[DictKeyType, Any]:
+        return dict(self.items_ex(resolve=True, keys=None)).items()
+
+    def setdefault(self, key: DictKeyType, default: Any = None) -> Any:
+        if key in self:
+            ret = self.__getitem__(key)
+        else:
+            ret = default
+            self.__setitem__(key, default)
+        return ret
+
+    def items_ex(
+        self, resolve: bool = True, keys: Optional[Sequence[DictKeyType]] = None
+    ) -> List[Tuple[DictKeyType, Any]]:
+        items: List[Tuple[DictKeyType, Any]] = []
+
+        if self._is_none():
+            self._format_and_raise(
+                key=None,
+                value=None,
+                cause=TypeError("Cannot iterate a DictConfig object representing None"),
+            )
+        if self._is_missing():
+            raise MissingMandatoryValue("Cannot iterate a missing DictConfig")
+
+        for key in self.keys():
+            if resolve:
+                value = self[key]
+            else:
+                value = self.__dict__["_content"][key]
+                if isinstance(value, ValueNode):
+                    value = value._value()
+            if keys is None or key in keys:
+                items.append((key, value))
+
+        return items
+
+    def __eq__(self, other: Any) -> bool:
+        if other is None:
+            return self.__dict__["_content"] is None
+        if is_primitive_dict(other) or is_structured_config(other):
+            other = DictConfig(other, flags={"allow_objects": True})
+            return DictConfig._dict_conf_eq(self, other)
+        if isinstance(other, DictConfig):
+            return DictConfig._dict_conf_eq(self, other)
+        if self._is_missing():
+            return _is_missing_literal(other)
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> bool:
+        x = self.__eq__(other)
+        if x is not NotImplemented:
+            return not x
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def _promote(self, type_or_prototype: Optional[Type[Any]]) -> None:
+        """
+        Retypes a node.
+        This should only be used in rare circumstances, where you want to dynamically change
+        the runtime structured-type of a DictConfig.
+        It will change the type and add the additional fields based on the input class or object
+        """
+        if type_or_prototype is None:
+            return
+        if not is_structured_config(type_or_prototype):
+            raise ValueError(f"Expected structured config class: {type_or_prototype}")
+
+        from omegaconf import OmegaConf
+
+        proto: DictConfig = OmegaConf.structured(type_or_prototype)
+        object_type = proto._metadata.object_type
+        # remove the type to prevent assignment validation from rejecting the promotion.
+        proto._metadata.object_type = None
+        self.merge_with(proto)
+        # restore the type.
+        self._metadata.object_type = object_type
+
+    def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None:
+        try:
+            previous_content = self.__dict__["_content"]
+            self._set_value_impl(value, flags)
+        except Exception as e:
+            self.__dict__["_content"] = previous_content
+            raise e
+
+    def _set_value_impl(
+        self, value: Any, flags: Optional[Dict[str, bool]] = None
+    ) -> None:
+        from omegaconf import MISSING, flag_override
+
+        if flags is None:
+            flags = {}
+
+        assert not isinstance(value, ValueNode)
+        self._validate_set(key=None, value=value)
+
+        if _is_none(value, resolve=True):
+            self.__dict__["_content"] = None
+            self._metadata.object_type = None
+        elif _is_interpolation(value, strict_interpolation_validation=True):
+            self.__dict__["_content"] = value
+            self._metadata.object_type = None
+        elif _is_missing_value(value):
+            self.__dict__["_content"] = MISSING
+            self._metadata.object_type = None
+        else:
+            self.__dict__["_content"] = {}
+            if is_structured_config(value):
+                self._metadata.object_type = None
+                ao = self._get_flag("allow_objects")
+                data = get_structured_config_data(value, allow_objects=ao)
+                with flag_override(self, ["struct", "readonly"], False):
+                    for k, v in data.items():
+                        self.__setitem__(k, v)
+                self._metadata.object_type = get_type_of(value)
+
+            elif isinstance(value, DictConfig):
+                self._metadata.flags = copy.deepcopy(flags)
+                with flag_override(self, ["struct", "readonly"], False):
+                    for k, v in value.__dict__["_content"].items():
+                        self.__setitem__(k, v)
+                self._metadata.object_type = value._metadata.object_type
+
+            elif isinstance(value, dict):
+                with flag_override(self, ["struct", "readonly"], False):
+                    for k, v in value.items():
+                        self.__setitem__(k, v)
+                self._metadata.object_type = dict
+
+            else:  # pragma: no cover
+                msg = f"Unsupported value type: {value}"
+                raise ValidationError(msg)
+
+    @staticmethod
+    def _dict_conf_eq(d1: "DictConfig", d2: "DictConfig") -> bool:
+
+        d1_none = d1.__dict__["_content"] is None
+        d2_none = d2.__dict__["_content"] is None
+        if d1_none and d2_none:
+            return True
+        if d1_none != d2_none:
+            return False
+
+        assert isinstance(d1, DictConfig)
+        assert isinstance(d2, DictConfig)
+        if len(d1) != len(d2):
+            return False
+        if d1._is_missing() or d2._is_missing():
+            return d1._is_missing() is d2._is_missing()
+
+        for k, v in d1.items_ex(resolve=False):
+            if k not in d2.__dict__["_content"]:
+                return False
+            if not BaseContainer._item_eq(d1, k, d2, k):
+                return False
+
+        return True
+
+    def _to_object(self) -> Any:
+        """
+        Instantiate an instance of `self._metadata.object_type`.
+        This requires `self` to be a structured config.
+        Nested subconfigs are converted by calling `OmegaConf.to_object`.
+        """
+        from omegaconf import OmegaConf
+
+        object_type = self._metadata.object_type
+        assert is_structured_config(object_type)
+        init_field_names = set(get_structured_config_init_field_names(object_type))
+
+        init_field_items: Dict[str, Any] = {}
+        non_init_field_items: Dict[str, Any] = {}
+        for k in self.keys():
+            assert isinstance(k, str)
+            node = self._get_child(k)
+            assert isinstance(node, Node)
+            try:
+                node = node._dereference_node()
+            except InterpolationResolutionError as e:
+                self._format_and_raise(key=k, value=None, cause=e)
+            if node._is_missing():
+                if k not in init_field_names:
+                    continue  # MISSING is ignored for init=False fields
+                self._format_and_raise(
+                    key=k,
+                    value=None,
+                    cause=MissingMandatoryValue(
+                        "Structured config of type `$OBJECT_TYPE` has missing mandatory value: $KEY"
+                    ),
+                )
+            if isinstance(node, Container):
+                v = OmegaConf.to_object(node)
+            else:
+                v = node._value()
+
+            if k in init_field_names:
+                init_field_items[k] = v
+            else:
+                non_init_field_items[k] = v
+
+        try:
+            result = object_type(**init_field_items)
+        except TypeError as exc:
+            self._format_and_raise(
+                key=None,
+                value=None,
+                cause=exc,
+                msg="Could not create instance of `$OBJECT_TYPE`: " + str(exc),
+            )
+
+        for k, v in non_init_field_items.items():
+            setattr(result, k, v)
+        return result

mantis_evalkit/lib/python3.10/site-packages/omegaconf/grammar/gen/OmegaConfGrammarLexer.py

@@ -0,0 +1,337 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarLexer.g4 by ANTLR 4.9.3
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\36")
+        buf.write("\u01e7\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5")
+        buf.write("\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13")
+        buf.write("\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t")
+        buf.write("\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26")
+        buf.write("\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34")
+        buf.write("\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t")
+        buf.write("\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4")
+        buf.write("+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62")
+        buf.write("\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\3\2\3\2")
+        buf.write("\3\3\3\3\3\4\3\4\3\4\5\4y\n\4\3\4\7\4|\n\4\f\4\16\4\177")
+        buf.write("\13\4\5\4\u0081\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3")
+        buf.write("\7\7\7\u008c\n\7\f\7\16\7\u008f\13\7\3\7\3\7\3\b\7\b\u0094")
+        buf.write("\n\b\f\b\16\b\u0097\13\b\3\b\3\b\3\b\3\b\3\t\6\t\u009e")
+        buf.write("\n\t\r\t\16\t\u009f\3\n\6\n\u00a3\n\n\r\n\16\n\u00a4\3")
+        buf.write("\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\5\f\u00b1\n")
+        buf.write("\f\3\f\3\f\3\r\3\r\5\r\u00b7\n\r\3\r\3\r\3\16\5\16\u00bc")
+        buf.write("\n\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20")
+        buf.write("\3\20\3\20\3\21\5\21\u00cb\n\21\3\21\3\21\5\21\u00cf\n")
+        buf.write("\21\3\22\3\22\5\22\u00d3\n\22\3\23\5\23\u00d6\n\23\3\23")
+        buf.write("\3\23\3\24\5\24\u00db\n\24\3\24\3\24\5\24\u00df\n\24\3")
+        buf.write("\25\3\25\3\25\3\25\5\25\u00e5\n\25\3\25\3\25\3\25\5\25")
+        buf.write("\u00ea\n\25\3\25\7\25\u00ed\n\25\f\25\16\25\u00f0\13\25")
+        buf.write("\5\25\u00f2\n\25\3\26\3\26\5\26\u00f6\n\26\3\26\3\26\5")
+        buf.write("\26\u00fa\n\26\3\26\3\26\5\26\u00fe\n\26\3\26\7\26\u0101")
+        buf.write("\n\26\f\26\16\26\u0104\13\26\3\27\5\27\u0107\n\27\3\27")
+        buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u0111\n\27\3")
+        buf.write("\30\5\30\u0114\n\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\5\31\u0121\n\31\3\32\3\32\3\32\3")
+        buf.write("\32\3\32\3\33\3\33\3\34\3\34\5\34\u012c\n\34\3\34\3\34")
+        buf.write("\3\34\7\34\u0131\n\34\f\34\16\34\u0134\13\34\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\6\35")
+        buf.write("\u014d\n\35\r\35\16\35\u014e\3\36\6\36\u0152\n\36\r\36")
+        buf.write("\16\36\u0153\3\37\3\37\5\37\u0158\n\37\3\37\3\37\3\37")
+        buf.write("\3 \5 \u015e\n \3 \3 \5 \u0162\n \3 \3 \3 \3!\5!\u0168")
+        buf.write("\n!\3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3#\3$\3$\3$\3$\3%\3%")
+        buf.write("\3%\3%\3&\6&\u017d\n&\r&\16&\u017e\3\'\3\'\3\'\3\'\3\'")
+        buf.write("\3(\3(\3(\3(\3)\7)\u018b\n)\f)\16)\u018e\13)\3)\3)\3)")
+        buf.write("\3)\3*\3*\3*\3*\3+\7+\u0199\n+\f+\16+\u019c\13+\3+\3+")
+        buf.write("\3+\3+\3+\3,\6,\u01a4\n,\r,\16,\u01a5\3-\6-\u01a9\n-\r")
+        buf.write("-\16-\u01aa\3-\3-\3.\3.\3.\3.\3/\3/\3/\3/\3/\3\60\3\60")
+        buf.write("\3\60\3\60\3\60\3\61\7\61\u01be\n\61\f\61\16\61\u01c1")
+        buf.write("\13\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\7")
+        buf.write("\63\u01cc\n\63\f\63\16\63\u01cf\13\63\3\63\3\63\3\63\3")
+        buf.write("\63\3\63\3\64\6\64\u01d7\n\64\r\64\16\64\u01d8\3\64\3")
+        buf.write("\64\3\65\6\65\u01de\n\65\r\65\16\65\u01df\3\65\3\65\3")
+        buf.write("\66\3\66\3\66\3\66\2\2\67\7\2\t\2\13\2\r\2\17\2\21\3\23")
+        buf.write("\4\25\5\27\2\31\34\33\6\35\7\37\b!\t#\n%\13\'\f)\r+\16")
+        buf.write("-\2/\2\61\17\63\20\65\21\67\229\23;\24=\25?\26A\2C\2E")
+        buf.write("\27G\30I\35K\36M\2O\31Q\2S\32U\2W\2Y\2[\33]\2_\2a\2c\2")
+        buf.write("e\2g\2i\2k\2m\2o\2\7\2\3\4\5\6\32\4\2C\\c|\3\2\62;\3\2")
+        buf.write("\63;\3\2&&\4\2&&^^\4\2GGgg\4\2--//\4\2KKkk\4\2PPpp\4\2")
+        buf.write("HHhh\4\2CCcc\4\2VVvv\4\2TTtt\4\2WWww\4\2NNnn\4\2UUuu\b")
+        buf.write("\2&\',-/\61AB^^~~\4\2//aa\4\2\13\13\"\"\13\2\13\13\"\"")
+        buf.write("$$)+\60\60<<]_}}\177\177\4\2&&))\5\2&&))^^\4\2$$&&\5\2")
+        buf.write("$$&&^^\2\u0218\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
+        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\3\33\3\2\2\2\3")
+        buf.write("\35\3\2\2\2\3\37\3\2\2\2\3!\3\2\2\2\3#\3\2\2\2\3%\3\2")
+        buf.write("\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\3\61\3\2\2\2\3")
+        buf.write("\63\3\2\2\2\3\65\3\2\2\2\3\67\3\2\2\2\39\3\2\2\2\3;\3")
+        buf.write("\2\2\2\3=\3\2\2\2\3?\3\2\2\2\4A\3\2\2\2\4C\3\2\2\2\4E")
+        buf.write("\3\2\2\2\4G\3\2\2\2\4I\3\2\2\2\4K\3\2\2\2\4M\3\2\2\2\4")
+        buf.write("O\3\2\2\2\5Q\3\2\2\2\5S\3\2\2\2\5U\3\2\2\2\5W\3\2\2\2")
+        buf.write("\5Y\3\2\2\2\5[\3\2\2\2\5]\3\2\2\2\5_\3\2\2\2\6a\3\2\2")
+        buf.write("\2\6c\3\2\2\2\6e\3\2\2\2\6g\3\2\2\2\6i\3\2\2\2\6k\3\2")
+        buf.write("\2\2\6m\3\2\2\2\6o\3\2\2\2\7q\3\2\2\2\ts\3\2\2\2\13\u0080")
+        buf.write("\3\2\2\2\r\u0082\3\2\2\2\17\u0085\3\2\2\2\21\u008d\3\2")
+        buf.write("\2\2\23\u0095\3\2\2\2\25\u009d\3\2\2\2\27\u00a2\3\2\2")
+        buf.write("\2\31\u00a8\3\2\2\2\33\u00ac\3\2\2\2\35\u00b4\3\2\2\2")
+        buf.write("\37\u00bb\3\2\2\2!\u00c1\3\2\2\2#\u00c5\3\2\2\2%\u00ca")
+        buf.write("\3\2\2\2\'\u00d0\3\2\2\2)\u00d5\3\2\2\2+\u00da\3\2\2\2")
+        buf.write("-\u00f1\3\2\2\2/\u00f5\3\2\2\2\61\u0106\3\2\2\2\63\u0113")
+        buf.write("\3\2\2\2\65\u0120\3\2\2\2\67\u0122\3\2\2\29\u0127\3\2")
+        buf.write("\2\2;\u012b\3\2\2\2=\u014c\3\2\2\2?\u0151\3\2\2\2A\u0155")
+        buf.write("\3\2\2\2C\u015d\3\2\2\2E\u0167\3\2\2\2G\u016d\3\2\2\2")
+        buf.write("I\u016f\3\2\2\2K\u0173\3\2\2\2M\u0177\3\2\2\2O\u017c\3")
+        buf.write("\2\2\2Q\u0180\3\2\2\2S\u0185\3\2\2\2U\u018c\3\2\2\2W\u0193")
+        buf.write("\3\2\2\2Y\u019a\3\2\2\2[\u01a3\3\2\2\2]\u01a8\3\2\2\2")
+        buf.write("_\u01ae\3\2\2\2a\u01b2\3\2\2\2c\u01b7\3\2\2\2e\u01bf\3")
+        buf.write("\2\2\2g\u01c6\3\2\2\2i\u01cd\3\2\2\2k\u01d6\3\2\2\2m\u01dd")
+        buf.write("\3\2\2\2o\u01e3\3\2\2\2qr\t\2\2\2r\b\3\2\2\2st\t\3\2\2")
+        buf.write("t\n\3\2\2\2u\u0081\7\62\2\2v}\t\4\2\2wy\7a\2\2xw\3\2\2")
+        buf.write("\2xy\3\2\2\2yz\3\2\2\2z|\5\t\3\2{x\3\2\2\2|\177\3\2\2")
+        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080")
+        buf.write("u\3\2\2\2\u0080v\3\2\2\2\u0081\f\3\2\2\2\u0082\u0083\7")
+        buf.write("^\2\2\u0083\u0084\7^\2\2\u0084\16\3\2\2\2\u0085\u0086")
+        buf.write("\5\33\f\2\u0086\u0087\3\2\2\2\u0087\u0088\b\6\2\2\u0088")
+        buf.write("\u0089\b\6\3\2\u0089\20\3\2\2\2\u008a\u008c\n\5\2\2\u008b")
+        buf.write("\u008a\3\2\2\2\u008c\u008f\3\2\2\2\u008d\u008b\3\2\2\2")
+        buf.write("\u008d\u008e\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u008d\3")
+        buf.write("\2\2\2\u0090\u0091\n\6\2\2\u0091\22\3\2\2\2\u0092\u0094")
+        buf.write("\5\r\5\2\u0093\u0092\3\2\2\2\u0094\u0097\3\2\2\2\u0095")
+        buf.write("\u0093\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0098\3\2\2\2")
+        buf.write("\u0097\u0095\3\2\2\2\u0098\u0099\7^\2\2\u0099\u009a\7")
+        buf.write("&\2\2\u009a\u009b\7}\2\2\u009b\24\3\2\2\2\u009c\u009e")
+        buf.write("\5\r\5\2\u009d\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f")
+        buf.write("\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\26\3\2\2\2\u00a1")
+        buf.write("\u00a3\7^\2\2\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2")
+        buf.write("\u00a4\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\3")
+        buf.write("\2\2\2\u00a6\u00a7\b\n\4\2\u00a7\30\3\2\2\2\u00a8\u00a9")
+        buf.write("\7&\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\b\13\4\2\u00ab")
+        buf.write("\32\3\2\2\2\u00ac\u00ad\7&\2\2\u00ad\u00ae\7}\2\2\u00ae")
+        buf.write("\u00b0\3\2\2\2\u00af\u00b1\5?\36\2\u00b0\u00af\3\2\2\2")
+        buf.write("\u00b0\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\b")
+        buf.write("\f\3\2\u00b3\34\3\2\2\2\u00b4\u00b6\7}\2\2\u00b5\u00b7")
+        buf.write("\5?\36\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7")
+        buf.write("\u00b8\3\2\2\2\u00b8\u00b9\b\r\5\2\u00b9\36\3\2\2\2\u00ba")
+        buf.write("\u00bc\5?\36\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2")
+        buf.write("\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\177\2\2\u00be\u00bf")
+        buf.write("\3\2\2\2\u00bf\u00c0\b\16\6\2\u00c0 \3\2\2\2\u00c1\u00c2")
+        buf.write("\7)\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c4\b\17\7\2\u00c4")
+        buf.write("\"\3\2\2\2\u00c5\u00c6\7$\2\2\u00c6\u00c7\3\2\2\2\u00c7")
+        buf.write("\u00c8\b\20\b\2\u00c8$\3\2\2\2\u00c9\u00cb\5?\36\2\u00ca")
+        buf.write("\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2")
+        buf.write("\u00cc\u00ce\7.\2\2\u00cd\u00cf\5?\36\2\u00ce\u00cd\3")
+        buf.write("\2\2\2\u00ce\u00cf\3\2\2\2\u00cf&\3\2\2\2\u00d0\u00d2")
+        buf.write("\7]\2\2\u00d1\u00d3\5?\36\2\u00d2\u00d1\3\2\2\2\u00d2")
+        buf.write("\u00d3\3\2\2\2\u00d3(\3\2\2\2\u00d4\u00d6\5?\36\2\u00d5")
+        buf.write("\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d7\3\2\2\2")
+        buf.write("\u00d7\u00d8\7_\2\2\u00d8*\3\2\2\2\u00d9\u00db\5?\36\2")
+        buf.write("\u00da\u00d9\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3")
+        buf.write("\2\2\2\u00dc\u00de\7<\2\2\u00dd\u00df\5?\36\2\u00de\u00dd")
+        buf.write("\3\2\2\2\u00de\u00df\3\2\2\2\u00df,\3\2\2\2\u00e0\u00e1")
+        buf.write("\5\13\4\2\u00e1\u00e2\7\60\2\2\u00e2\u00f2\3\2\2\2\u00e3")
+        buf.write("\u00e5\5\13\4\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5\3\2\2")
+        buf.write("\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\7\60\2\2\u00e7\u00ee")
+        buf.write("\5\t\3\2\u00e8\u00ea\7a\2\2\u00e9\u00e8\3\2\2\2\u00e9")
+        buf.write("\u00ea\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ed\5\t\3\2")
+        buf.write("\u00ec\u00e9\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3")
+        buf.write("\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee")
+        buf.write("\3\2\2\2\u00f1\u00e0\3\2\2\2\u00f1\u00e4\3\2\2\2\u00f2")
+        buf.write(".\3\2\2\2\u00f3\u00f6\5\13\4\2\u00f4\u00f6\5-\25\2\u00f5")
+        buf.write("\u00f3\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2")
+        buf.write("\u00f7\u00f9\t\7\2\2\u00f8\u00fa\t\b\2\2\u00f9\u00f8\3")
+        buf.write("\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u0102")
+        buf.write("\5\t\3\2\u00fc\u00fe\7a\2\2\u00fd\u00fc\3\2\2\2\u00fd")
+        buf.write("\u00fe\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0101\5\t\3\2")
+        buf.write("\u0100\u00fd\3\2\2\2\u0101\u0104\3\2\2\2\u0102\u0100\3")
+        buf.write("\2\2\2\u0102\u0103\3\2\2\2\u0103\60\3\2\2\2\u0104\u0102")
+        buf.write("\3\2\2\2\u0105\u0107\t\b\2\2\u0106\u0105\3\2\2\2\u0106")
+        buf.write("\u0107\3\2\2\2\u0107\u0110\3\2\2\2\u0108\u0111\5-\25\2")
+        buf.write("\u0109\u0111\5/\26\2\u010a\u010b\t\t\2\2\u010b\u010c\t")
+        buf.write("\n\2\2\u010c\u0111\t\13\2\2\u010d\u010e\t\n\2\2\u010e")
+        buf.write("\u010f\t\f\2\2\u010f\u0111\t\n\2\2\u0110\u0108\3\2\2\2")
+        buf.write("\u0110\u0109\3\2\2\2\u0110\u010a\3\2\2\2\u0110\u010d\3")
+        buf.write("\2\2\2\u0111\62\3\2\2\2\u0112\u0114\t\b\2\2\u0113\u0112")
+        buf.write("\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0115\3\2\2\2\u0115")
+        buf.write("\u0116\5\13\4\2\u0116\64\3\2\2\2\u0117\u0118\t\r\2\2\u0118")
+        buf.write("\u0119\t\16\2\2\u0119\u011a\t\17\2\2\u011a\u0121\t\7\2")
+        buf.write("\2\u011b\u011c\t\13\2\2\u011c\u011d\t\f\2\2\u011d\u011e")
+        buf.write("\t\20\2\2\u011e\u011f\t\21\2\2\u011f\u0121\t\7\2\2\u0120")
+        buf.write("\u0117\3\2\2\2\u0120\u011b\3\2\2\2\u0121\66\3\2\2\2\u0122")
+        buf.write("\u0123\t\n\2\2\u0123\u0124\t\17\2\2\u0124\u0125\t\20\2")
+        buf.write("\2\u0125\u0126\t\20\2\2\u01268\3\2\2\2\u0127\u0128\t\22")
+        buf.write("\2\2\u0128:\3\2\2\2\u0129\u012c\5\7\2\2\u012a\u012c\7")
+        buf.write("a\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u0132")
+        buf.write("\3\2\2\2\u012d\u0131\5\7\2\2\u012e\u0131\5\t\3\2\u012f")
+        buf.write("\u0131\t\23\2\2\u0130\u012d\3\2\2\2\u0130\u012e\3\2\2")
+        buf.write("\2\u0130\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130")
+        buf.write("\3\2\2\2\u0132\u0133\3\2\2\2\u0133<\3\2\2\2\u0134\u0132")
+        buf.write("\3\2\2\2\u0135\u014d\5\r\5\2\u0136\u0137\7^\2\2\u0137")
+        buf.write("\u014d\7*\2\2\u0138\u0139\7^\2\2\u0139\u014d\7+\2\2\u013a")
+        buf.write("\u013b\7^\2\2\u013b\u014d\7]\2\2\u013c\u013d\7^\2\2\u013d")
+        buf.write("\u014d\7_\2\2\u013e\u013f\7^\2\2\u013f\u014d\7}\2\2\u0140")
+        buf.write("\u0141\7^\2\2\u0141\u014d\7\177\2\2\u0142\u0143\7^\2\2")
+        buf.write("\u0143\u014d\7<\2\2\u0144\u0145\7^\2\2\u0145\u014d\7?")
+        buf.write("\2\2\u0146\u0147\7^\2\2\u0147\u014d\7.\2\2\u0148\u0149")
+        buf.write("\7^\2\2\u0149\u014d\7\"\2\2\u014a\u014b\7^\2\2\u014b\u014d")
+        buf.write("\7\13\2\2\u014c\u0135\3\2\2\2\u014c\u0136\3\2\2\2\u014c")
+        buf.write("\u0138\3\2\2\2\u014c\u013a\3\2\2\2\u014c\u013c\3\2\2\2")
+        buf.write("\u014c\u013e\3\2\2\2\u014c\u0140\3\2\2\2\u014c\u0142\3")
+        buf.write("\2\2\2\u014c\u0144\3\2\2\2\u014c\u0146\3\2\2\2\u014c\u0148")
+        buf.write("\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014e\3\2\2\2\u014e")
+        buf.write("\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f>\3\2\2\2\u0150")
+        buf.write("\u0152\t\24\2\2\u0151\u0150\3\2\2\2\u0152\u0153\3\2\2")
+        buf.write("\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154@\3\2")
+        buf.write("\2\2\u0155\u0157\5\33\f\2\u0156\u0158\5?\36\2\u0157\u0156")
+        buf.write("\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159")
+        buf.write("\u015a\b\37\2\2\u015a\u015b\b\37\3\2\u015bB\3\2\2\2\u015c")
+        buf.write("\u015e\5?\36\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2")
+        buf.write("\u015e\u015f\3\2\2\2\u015f\u0161\7<\2\2\u0160\u0162\5")
+        buf.write("?\36\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163")
+        buf.write("\3\2\2\2\u0163\u0164\b \t\2\u0164\u0165\b \n\2\u0165D")
+        buf.write("\3\2\2\2\u0166\u0168\5?\36\2\u0167\u0166\3\2\2\2\u0167")
+        buf.write("\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\7\177\2")
+        buf.write("\2\u016a\u016b\3\2\2\2\u016b\u016c\b!\6\2\u016cF\3\2\2")
+        buf.write("\2\u016d\u016e\7\60\2\2\u016eH\3\2\2\2\u016f\u0170\7]")
+        buf.write("\2\2\u0170\u0171\3\2\2\2\u0171\u0172\b#\13\2\u0172J\3")
+        buf.write("\2\2\2\u0173\u0174\7_\2\2\u0174\u0175\3\2\2\2\u0175\u0176")
+        buf.write("\b$\f\2\u0176L\3\2\2\2\u0177\u0178\5;\34\2\u0178\u0179")
+        buf.write("\3\2\2\2\u0179\u017a\b%\r\2\u017aN\3\2\2\2\u017b\u017d")
+        buf.write("\n\25\2\2\u017c\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e")
+        buf.write("\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017fP\3\2\2\2\u0180")
+        buf.write("\u0181\5\33\f\2\u0181\u0182\3\2\2\2\u0182\u0183\b\'\2")
+        buf.write("\2\u0183\u0184\b\'\3\2\u0184R\3\2\2\2\u0185\u0186\7)\2")
+        buf.write("\2\u0186\u0187\3\2\2\2\u0187\u0188\b(\6\2\u0188T\3\2\2")
+        buf.write("\2\u0189\u018b\n\26\2\2\u018a\u0189\3\2\2\2\u018b\u018e")
+        buf.write("\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d\3\2\2\2\u018d")
+        buf.write("\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f\u0190\n\27\2")
+        buf.write("\2\u0190\u0191\3\2\2\2\u0191\u0192\b)\4\2\u0192V\3\2\2")
+        buf.write("\2\u0193\u0194\5\23\b\2\u0194\u0195\3\2\2\2\u0195\u0196")
+        buf.write("\b*\16\2\u0196X\3\2\2\2\u0197\u0199\5\r\5\2\u0198\u0197")
+        buf.write("\3\2\2\2\u0199\u019c\3\2\2\2\u019a\u0198\3\2\2\2\u019a")
+        buf.write("\u019b\3\2\2\2\u019b\u019d\3\2\2\2\u019c\u019a\3\2\2\2")
+        buf.write("\u019d\u019e\7^\2\2\u019e\u019f\7)\2\2\u019f\u01a0\3\2")
+        buf.write("\2\2\u01a0\u01a1\b+\17\2\u01a1Z\3\2\2\2\u01a2\u01a4\5")
+        buf.write("\r\5\2\u01a3\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a3")
+        buf.write("\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\\\3\2\2\2\u01a7\u01a9")
+        buf.write("\7^\2\2\u01a8\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa")
+        buf.write("\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\3\2\2\2")
+        buf.write("\u01ac\u01ad\b-\4\2\u01ad^\3\2\2\2\u01ae\u01af\7&\2\2")
+        buf.write("\u01af\u01b0\3\2\2\2\u01b0\u01b1\b.\4\2\u01b1`\3\2\2\2")
+        buf.write("\u01b2\u01b3\5\33\f\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5")
+        buf.write("\b/\2\2\u01b5\u01b6\b/\3\2\u01b6b\3\2\2\2\u01b7\u01b8")
+        buf.write("\7$\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\b\60\20\2\u01ba")
+        buf.write("\u01bb\b\60\6\2\u01bbd\3\2\2\2\u01bc\u01be\n\30\2\2\u01bd")
+        buf.write("\u01bc\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2")
+        buf.write("\u01bf\u01c0\3\2\2\2\u01c0\u01c2\3\2\2\2\u01c1\u01bf\3")
+        buf.write("\2\2\2\u01c2\u01c3\n\31\2\2\u01c3\u01c4\3\2\2\2\u01c4")
+        buf.write("\u01c5\b\61\4\2\u01c5f\3\2\2\2\u01c6\u01c7\5\23\b\2\u01c7")
+        buf.write("\u01c8\3\2\2\2\u01c8\u01c9\b\62\16\2\u01c9h\3\2\2\2\u01ca")
+        buf.write("\u01cc\5\r\5\2\u01cb\u01ca\3\2\2\2\u01cc\u01cf\3\2\2\2")
+        buf.write("\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01d0\3")
+        buf.write("\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d1\7^\2\2\u01d1\u01d2")
+        buf.write("\7$\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\b\63\17\2\u01d4")
+        buf.write("j\3\2\2\2\u01d5\u01d7\5\r\5\2\u01d6\u01d5\3\2\2\2\u01d7")
+        buf.write("\u01d8\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2")
+        buf.write("\u01d9\u01da\3\2\2\2\u01da\u01db\b\64\21\2\u01dbl\3\2")
+        buf.write("\2\2\u01dc\u01de\7^\2\2\u01dd\u01dc\3\2\2\2\u01de\u01df")
+        buf.write("\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0")
+        buf.write("\u01e1\3\2\2\2\u01e1\u01e2\b\65\4\2\u01e2n\3\2\2\2\u01e3")
+        buf.write("\u01e4\7&\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\b\66\4\2")
+        buf.write("\u01e6p\3\2\2\2\66\2\3\4\5\6x}\u0080\u008d\u0095\u009f")
+        buf.write("\u00a4\u00b0\u00b6\u00bb\u00ca\u00ce\u00d2\u00d5\u00da")
+        buf.write("\u00de\u00e4\u00e9\u00ee\u00f1\u00f5\u00f9\u00fd\u0102")
+        buf.write("\u0106\u0110\u0113\u0120\u012b\u0130\u0132\u014c\u014e")
+        buf.write("\u0153\u0157\u015d\u0161\u0167\u017e\u018c\u019a\u01a5")
+        buf.write("\u01aa\u01bf\u01cd\u01d8\u01df\22\t\6\2\7\4\2\t\3\2\7")
+        buf.write("\3\2\6\2\2\7\5\2\7\6\2\t\16\2\4\3\2\t\f\2\t\r\2\t\24\2")
+        buf.write("\t\4\2\t\25\2\t\32\2\t\33\2")
+        return buf.getvalue()
+
+
+class OmegaConfGrammarLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    VALUE_MODE = 1
+    INTERPOLATION_MODE = 2
+    QUOTED_SINGLE_MODE = 3
+    QUOTED_DOUBLE_MODE = 4
+
+    ANY_STR = 1
+    ESC_INTER = 2
+    TOP_ESC = 3
+    INTER_OPEN = 4
+    BRACE_OPEN = 5
+    BRACE_CLOSE = 6
+    QUOTE_OPEN_SINGLE = 7
+    QUOTE_OPEN_DOUBLE = 8
+    COMMA = 9
+    BRACKET_OPEN = 10
+    BRACKET_CLOSE = 11
+    COLON = 12
+    FLOAT = 13
+    INT = 14
+    BOOL = 15
+    NULL = 16
+    UNQUOTED_CHAR = 17
+    ID = 18
+    ESC = 19
+    WS = 20
+    INTER_CLOSE = 21
+    DOT = 22
+    INTER_KEY = 23
+    MATCHING_QUOTE_CLOSE = 24
+    QUOTED_ESC = 25
+    DOLLAR = 26
+    INTER_BRACKET_OPEN = 27
+    INTER_BRACKET_CLOSE = 28
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE", "VALUE_MODE", "INTERPOLATION_MODE", "QUOTED_SINGLE_MODE", 
+                  "QUOTED_DOUBLE_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'.'", "'['", "']'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", "BRACE_OPEN", 
+            "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", "QUOTE_OPEN_DOUBLE", "COMMA", 
+            "BRACKET_OPEN", "BRACKET_CLOSE", "COLON", "FLOAT", "INT", "BOOL", 
+            "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "INTER_CLOSE", "DOT", 
+            "INTER_KEY", "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", 
+            "INTER_BRACKET_OPEN", "INTER_BRACKET_CLOSE" ]
+
+    ruleNames = [ "CHAR", "DIGIT", "INT_UNSIGNED", "ESC_BACKSLASH", "TOP_INTER_OPEN", 
+                  "ANY_STR", "ESC_INTER", "TOP_ESC", "BACKSLASHES", "DOLLAR", 
+                  "INTER_OPEN", "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", 
+                  "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", 
+                  "COLON", "POINT_FLOAT", "EXPONENT_FLOAT", "FLOAT", "INT", 
+                  "BOOL", "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "NESTED_INTER_OPEN", 
+                  "INTER_COLON", "INTER_CLOSE", "DOT", "INTER_BRACKET_OPEN", 
+                  "INTER_BRACKET_CLOSE", "INTER_ID", "INTER_KEY", "QSINGLE_INTER_OPEN", 
+                  "MATCHING_QUOTE_CLOSE", "QSINGLE_STR", "QSINGLE_ESC_INTER", 
+                  "QSINGLE_ESC_QUOTE", "QUOTED_ESC", "QSINGLE_BACKSLASHES", 
+                  "QSINGLE_DOLLAR", "QDOUBLE_INTER_OPEN", "QDOUBLE_CLOSE", 
+                  "QDOUBLE_STR", "QDOUBLE_ESC_INTER", "QDOUBLE_ESC_QUOTE", 
+                  "QDOUBLE_ESC", "QDOUBLE_BACKSLASHES", "QDOUBLE_DOLLAR" ]
+
+    grammarFileName = "OmegaConfGrammarLexer.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.3")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

mantis_evalkit/lib/python3.10/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py

@@ -0,0 +1,1595 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+	from typing import TextIO
+else:
+	from typing.io import TextIO
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\36")
+        buf.write("\u00b7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
+        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3\2\3\3\3")
+        buf.write("\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\6\4/\n\4\r\4\16\4\60\3")
+        buf.write("\5\3\5\3\5\3\5\5\5\67\n\5\3\6\3\6\5\6;\n\6\3\6\3\6\3\7")
+        buf.write("\3\7\3\7\3\7\7\7C\n\7\f\7\16\7F\13\7\5\7H\n\7\3\7\3\7")
+        buf.write("\3\b\3\b\3\b\3\b\3\t\3\t\3\t\5\tS\n\t\7\tU\n\t\f\t\16")
+        buf.write("\tX\13\t\3\t\3\t\5\t\\\n\t\6\t^\n\t\r\t\16\t_\5\tb\n\t")
+        buf.write("\3\n\3\n\5\nf\n\n\3\13\3\13\7\13j\n\13\f\13\16\13m\13")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\5\13t\n\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\7\13|\n\13\f\13\16\13\177\13\13\3\13\3")
+        buf.write("\13\3\f\3\f\3\f\3\f\5\f\u0087\n\f\3\f\3\f\3\r\3\r\3\r")
+        buf.write("\5\r\u008e\n\r\3\16\3\16\5\16\u0092\n\16\3\16\3\16\3\16")
+        buf.write("\5\16\u0097\n\16\7\16\u0099\n\16\f\16\16\16\u009c\13\16")
+        buf.write("\3\17\3\17\5\17\u00a0\n\17\3\17\3\17\3\20\3\20\3\20\3")
+        buf.write("\20\3\20\3\20\3\20\3\20\3\20\3\20\6\20\u00ae\n\20\r\20")
+        buf.write("\16\20\u00af\3\21\6\21\u00b3\n\21\r\21\16\21\u00b4\3\21")
+        buf.write("\2\2\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \2\4\3")
+        buf.write("\2\t\n\3\2\17\26\2\u00ce\2\"\3\2\2\2\4%\3\2\2\2\6.\3\2")
+        buf.write("\2\2\b\66\3\2\2\2\n8\3\2\2\2\f>\3\2\2\2\16K\3\2\2\2\20")
+        buf.write("a\3\2\2\2\22e\3\2\2\2\24g\3\2\2\2\26\u0082\3\2\2\2\30")
+        buf.write("\u008d\3\2\2\2\32\u0091\3\2\2\2\34\u009d\3\2\2\2\36\u00ad")
+        buf.write("\3\2\2\2 \u00b2\3\2\2\2\"#\5\6\4\2#$\7\2\2\3$\3\3\2\2")
+        buf.write("\2%&\5\b\5\2&\'\7\2\2\3\'\5\3\2\2\2(/\5\22\n\2)/\7\3\2")
+        buf.write("\2*/\7\25\2\2+/\7\4\2\2,/\7\5\2\2-/\7\33\2\2.(\3\2\2\2")
+        buf.write(".)\3\2\2\2.*\3\2\2\2.+\3\2\2\2.,\3\2\2\2.-\3\2\2\2/\60")
+        buf.write("\3\2\2\2\60.\3\2\2\2\60\61\3\2\2\2\61\7\3\2\2\2\62\67")
+        buf.write("\5\36\20\2\63\67\5\34\17\2\64\67\5\n\6\2\65\67\5\f\7\2")
+        buf.write("\66\62\3\2\2\2\66\63\3\2\2\2\66\64\3\2\2\2\66\65\3\2\2")
+        buf.write("\2\67\t\3\2\2\28:\7\f\2\29;\5\20\t\2:9\3\2\2\2:;\3\2\2")
+        buf.write("\2;<\3\2\2\2<=\7\r\2\2=\13\3\2\2\2>G\7\7\2\2?D\5\16\b")
+        buf.write("\2@A\7\13\2\2AC\5\16\b\2B@\3\2\2\2CF\3\2\2\2DB\3\2\2\2")
+        buf.write("DE\3\2\2\2EH\3\2\2\2FD\3\2\2\2G?\3\2\2\2GH\3\2\2\2HI\3")
+        buf.write("\2\2\2IJ\7\b\2\2J\r\3\2\2\2KL\5 \21\2LM\7\16\2\2MN\5\b")
+        buf.write("\5\2N\17\3\2\2\2OV\5\b\5\2PR\7\13\2\2QS\5\b\5\2RQ\3\2")
+        buf.write("\2\2RS\3\2\2\2SU\3\2\2\2TP\3\2\2\2UX\3\2\2\2VT\3\2\2\2")
+        buf.write("VW\3\2\2\2Wb\3\2\2\2XV\3\2\2\2Y[\7\13\2\2Z\\\5\b\5\2[")
+        buf.write("Z\3\2\2\2[\\\3\2\2\2\\^\3\2\2\2]Y\3\2\2\2^_\3\2\2\2_]")
+        buf.write("\3\2\2\2_`\3\2\2\2`b\3\2\2\2aO\3\2\2\2a]\3\2\2\2b\21\3")
+        buf.write("\2\2\2cf\5\24\13\2df\5\26\f\2ec\3\2\2\2ed\3\2\2\2f\23")
+        buf.write("\3\2\2\2gk\7\6\2\2hj\7\30\2\2ih\3\2\2\2jm\3\2\2\2ki\3")
+        buf.write("\2\2\2kl\3\2\2\2ls\3\2\2\2mk\3\2\2\2nt\5\30\r\2op\7\f")
+        buf.write("\2\2pq\5\30\r\2qr\7\r\2\2rt\3\2\2\2sn\3\2\2\2so\3\2\2")
+        buf.write("\2t}\3\2\2\2uv\7\30\2\2v|\5\30\r\2wx\7\f\2\2xy\5\30\r")
+        buf.write("\2yz\7\r\2\2z|\3\2\2\2{u\3\2\2\2{w\3\2\2\2|\177\3\2\2")
+        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080")
+        buf.write("\u0081\7\27\2\2\u0081\25\3\2\2\2\u0082\u0083\7\6\2\2\u0083")
+        buf.write("\u0084\5\32\16\2\u0084\u0086\7\16\2\2\u0085\u0087\5\20")
+        buf.write("\t\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088")
+        buf.write("\3\2\2\2\u0088\u0089\7\b\2\2\u0089\27\3\2\2\2\u008a\u008e")
+        buf.write("\5\22\n\2\u008b\u008e\7\24\2\2\u008c\u008e\7\31\2\2\u008d")
+        buf.write("\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c\3\2\2\2")
+        buf.write("\u008e\31\3\2\2\2\u008f\u0092\5\22\n\2\u0090\u0092\7\24")
+        buf.write("\2\2\u0091\u008f\3\2\2\2\u0091\u0090\3\2\2\2\u0092\u009a")
+        buf.write("\3\2\2\2\u0093\u0096\7\30\2\2\u0094\u0097\5\22\n\2\u0095")
+        buf.write("\u0097\7\24\2\2\u0096\u0094\3\2\2\2\u0096\u0095\3\2\2")
+        buf.write("\2\u0097\u0099\3\2\2\2\u0098\u0093\3\2\2\2\u0099\u009c")
+        buf.write("\3\2\2\2\u009a\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b")
+        buf.write("\33\3\2\2\2\u009c\u009a\3\2\2\2\u009d\u009f\t\2\2\2\u009e")
+        buf.write("\u00a0\5\6\4\2\u009f\u009e\3\2\2\2\u009f\u00a0\3\2\2\2")
+        buf.write("\u00a0\u00a1\3\2\2\2\u00a1\u00a2\7\32\2\2\u00a2\35\3\2")
+        buf.write("\2\2\u00a3\u00ae\7\24\2\2\u00a4\u00ae\7\22\2\2\u00a5\u00ae")
+        buf.write("\7\20\2\2\u00a6\u00ae\7\17\2\2\u00a7\u00ae\7\21\2\2\u00a8")
+        buf.write("\u00ae\7\23\2\2\u00a9\u00ae\7\16\2\2\u00aa\u00ae\7\25")
+        buf.write("\2\2\u00ab\u00ae\7\26\2\2\u00ac\u00ae\5\22\n\2\u00ad\u00a3")
+        buf.write("\3\2\2\2\u00ad\u00a4\3\2\2\2\u00ad\u00a5\3\2\2\2\u00ad")
+        buf.write("\u00a6\3\2\2\2\u00ad\u00a7\3\2\2\2\u00ad\u00a8\3\2\2\2")
+        buf.write("\u00ad\u00a9\3\2\2\2\u00ad\u00aa\3\2\2\2\u00ad\u00ab\3")
+        buf.write("\2\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00ad")
+        buf.write("\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\37\3\2\2\2\u00b1\u00b3")
+        buf.write("\t\3\2\2\u00b2\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4")
+        buf.write("\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5!\3\2\2\2\33.")
+        buf.write("\60\66:DGRV[_aeks{}\u0086\u008d\u0091\u0096\u009a\u009f")
+        buf.write("\u00ad\u00af\u00b4")
+        return buf.getvalue()
+
+
+class OmegaConfGrammarParser ( Parser ):
+
+    grammarFileName = "OmegaConfGrammarParser.g4"
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    sharedContextCache = PredictionContextCache()
+
+    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'.'", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'['", "']'" ]
+
+    symbolicNames = [ "<INVALID>", "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", 
+                      "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", 
+                      "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", 
+                      "COLON", "FLOAT", "INT", "BOOL", "NULL", "UNQUOTED_CHAR", 
+                      "ID", "ESC", "WS", "INTER_CLOSE", "DOT", "INTER_KEY", 
+                      "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", "INTER_BRACKET_OPEN", 
+                      "INTER_BRACKET_CLOSE" ]
+
+    RULE_configValue = 0
+    RULE_singleElement = 1
+    RULE_text = 2
+    RULE_element = 3
+    RULE_listContainer = 4
+    RULE_dictContainer = 5
+    RULE_dictKeyValuePair = 6
+    RULE_sequence = 7
+    RULE_interpolation = 8
+    RULE_interpolationNode = 9
+    RULE_interpolationResolver = 10
+    RULE_configKey = 11
+    RULE_resolverName = 12
+    RULE_quotedValue = 13
+    RULE_primitive = 14
+    RULE_dictKey = 15
+
+    ruleNames =  [ "configValue", "singleElement", "text", "element", "listContainer", 
+                   "dictContainer", "dictKeyValuePair", "sequence", "interpolation", 
+                   "interpolationNode", "interpolationResolver", "configKey", 
+                   "resolverName", "quotedValue", "primitive", "dictKey" ]
+
+    EOF = Token.EOF
+    ANY_STR=1
+    ESC_INTER=2
+    TOP_ESC=3
+    INTER_OPEN=4
+    BRACE_OPEN=5
+    BRACE_CLOSE=6
+    QUOTE_OPEN_SINGLE=7
+    QUOTE_OPEN_DOUBLE=8
+    COMMA=9
+    BRACKET_OPEN=10
+    BRACKET_CLOSE=11
+    COLON=12
+    FLOAT=13
+    INT=14
+    BOOL=15
+    NULL=16
+    UNQUOTED_CHAR=17
+    ID=18
+    ESC=19
+    WS=20
+    INTER_CLOSE=21
+    DOT=22
+    INTER_KEY=23
+    MATCHING_QUOTE_CLOSE=24
+    QUOTED_ESC=25
+    DOLLAR=26
+    INTER_BRACKET_OPEN=27
+    INTER_BRACKET_CLOSE=28
+
+    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.3")
+        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+        self._predicates = None
+
+
+
+
+    class ConfigValueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def text(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0)
+
+
+        def EOF(self):
+            return self.getToken(OmegaConfGrammarParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_configValue
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConfigValue" ):
+                listener.enterConfigValue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConfigValue" ):
+                listener.exitConfigValue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConfigValue" ):
+                return visitor.visitConfigValue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def configValue(self):
+
+        localctx = OmegaConfGrammarParser.ConfigValueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_configValue)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 32
+            self.text()
+            self.state = 33
+            self.match(OmegaConfGrammarParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SingleElementContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def element(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0)
+
+
+        def EOF(self):
+            return self.getToken(OmegaConfGrammarParser.EOF, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_singleElement
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSingleElement" ):
+                listener.enterSingleElement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSingleElement" ):
+                listener.exitSingleElement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSingleElement" ):
+                return visitor.visitSingleElement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def singleElement(self):
+
+        localctx = OmegaConfGrammarParser.SingleElementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_singleElement)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 35
+            self.element()
+            self.state = 36
+            self.match(OmegaConfGrammarParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class TextContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def ANY_STR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ANY_STR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ANY_STR, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def ESC_INTER(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC_INTER)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC_INTER, i)
+
+        def TOP_ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.TOP_ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.TOP_ESC, i)
+
+        def QUOTED_ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.QUOTED_ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.QUOTED_ESC, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_text
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterText" ):
+                listener.enterText(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitText" ):
+                listener.exitText(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitText" ):
+                return visitor.visitText(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def text(self):
+
+        localctx = OmegaConfGrammarParser.TextContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 4, self.RULE_text)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 44 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 44
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 38
+                    self.interpolation()
+                    pass
+                elif token in [OmegaConfGrammarParser.ANY_STR]:
+                    self.state = 39
+                    self.match(OmegaConfGrammarParser.ANY_STR)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC]:
+                    self.state = 40
+                    self.match(OmegaConfGrammarParser.ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC_INTER]:
+                    self.state = 41
+                    self.match(OmegaConfGrammarParser.ESC_INTER)
+                    pass
+                elif token in [OmegaConfGrammarParser.TOP_ESC]:
+                    self.state = 42
+                    self.match(OmegaConfGrammarParser.TOP_ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.QUOTED_ESC]:
+                    self.state = 43
+                    self.match(OmegaConfGrammarParser.QUOTED_ESC)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 46 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ElementContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def primitive(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.PrimitiveContext,0)
+
+
+        def quotedValue(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.QuotedValueContext,0)
+
+
+        def listContainer(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ListContainerContext,0)
+
+
+        def dictContainer(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.DictContainerContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_element
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterElement" ):
+                listener.enterElement(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitElement" ):
+                listener.exitElement(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitElement" ):
+                return visitor.visitElement(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def element(self):
+
+        localctx = OmegaConfGrammarParser.ElementContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_element)
+        try:
+            self.state = 52
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 48
+                self.primitive()
+                pass
+            elif token in [OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 49
+                self.quotedValue()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 50
+                self.listContainer()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACE_OPEN]:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 51
+                self.dictContainer()
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ListContainerContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def BRACKET_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, 0)
+
+        def BRACKET_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, 0)
+
+        def sequence(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_listContainer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterListContainer" ):
+                listener.enterListContainer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitListContainer" ):
+                listener.exitListContainer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitListContainer" ):
+                return visitor.visitListContainer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def listContainer(self):
+
+        localctx = OmegaConfGrammarParser.ListContainerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_listContainer)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 54
+            self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+            self.state = 56
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 55
+                self.sequence()
+
+
+            self.state = 58
+            self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictContainerContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def BRACE_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_OPEN, 0)
+
+        def BRACE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0)
+
+        def dictKeyValuePair(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.DictKeyValuePairContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyValuePairContext,i)
+
+
+        def COMMA(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COMMA)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COMMA, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictContainer
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictContainer" ):
+                listener.enterDictContainer(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictContainer" ):
+                listener.exitDictContainer(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictContainer" ):
+                return visitor.visitDictContainer(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictContainer(self):
+
+        localctx = OmegaConfGrammarParser.DictContainerContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 10, self.RULE_dictContainer)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 60
+            self.match(OmegaConfGrammarParser.BRACE_OPEN)
+            self.state = 69
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 61
+                self.dictKeyValuePair()
+                self.state = 66
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==OmegaConfGrammarParser.COMMA:
+                    self.state = 62
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 63
+                    self.dictKeyValuePair()
+                    self.state = 68
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+
+
+            self.state = 71
+            self.match(OmegaConfGrammarParser.BRACE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictKeyValuePairContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def dictKey(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyContext,0)
+
+
+        def COLON(self):
+            return self.getToken(OmegaConfGrammarParser.COLON, 0)
+
+        def element(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictKeyValuePair
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictKeyValuePair" ):
+                listener.enterDictKeyValuePair(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictKeyValuePair" ):
+                listener.exitDictKeyValuePair(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictKeyValuePair" ):
+                return visitor.visitDictKeyValuePair(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictKeyValuePair(self):
+
+        localctx = OmegaConfGrammarParser.DictKeyValuePairContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 12, self.RULE_dictKeyValuePair)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 73
+            self.dictKey()
+            self.state = 74
+            self.match(OmegaConfGrammarParser.COLON)
+            self.state = 75
+            self.element()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class SequenceContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def element(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.ElementContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,i)
+
+
+        def COMMA(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COMMA)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COMMA, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_sequence
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterSequence" ):
+                listener.enterSequence(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitSequence" ):
+                listener.exitSequence(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitSequence" ):
+                return visitor.visitSequence(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def sequence(self):
+
+        localctx = OmegaConfGrammarParser.SequenceContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 14, self.RULE_sequence)
+        self._la = 0 # Token type
+        try:
+            self.state = 95
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.BRACE_OPEN, OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, OmegaConfGrammarParser.BRACKET_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 77
+                self.element()
+                self.state = 84
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==OmegaConfGrammarParser.COMMA:
+                    self.state = 78
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 80
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                        self.state = 79
+                        self.element()
+
+
+                    self.state = 86
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                pass
+            elif token in [OmegaConfGrammarParser.COMMA]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 91 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 87
+                    self.match(OmegaConfGrammarParser.COMMA)
+                    self.state = 89
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                        self.state = 88
+                        self.element()
+
+
+                    self.state = 93 
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if not (_la==OmegaConfGrammarParser.COMMA):
+                        break
+
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolationNode(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationNodeContext,0)
+
+
+        def interpolationResolver(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationResolverContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolation
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolation" ):
+                listener.enterInterpolation(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolation" ):
+                listener.exitInterpolation(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolation" ):
+                return visitor.visitInterpolation(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolation(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 16, self.RULE_interpolation)
+        try:
+            self.state = 99
+            self._errHandler.sync(self)
+            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+            if la_ == 1:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 97
+                self.interpolationNode()
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 98
+                self.interpolationResolver()
+                pass
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationNodeContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INTER_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0)
+
+        def INTER_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_CLOSE, 0)
+
+        def configKey(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.ConfigKeyContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.ConfigKeyContext,i)
+
+
+        def BRACKET_OPEN(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BRACKET_OPEN)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, i)
+
+        def BRACKET_CLOSE(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BRACKET_CLOSE)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, i)
+
+        def DOT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.DOT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.DOT, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolationNode
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolationNode" ):
+                listener.enterInterpolationNode(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolationNode" ):
+                listener.exitInterpolationNode(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolationNode" ):
+                return visitor.visitInterpolationNode(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolationNode(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationNodeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 18, self.RULE_interpolationNode)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 101
+            self.match(OmegaConfGrammarParser.INTER_OPEN)
+            self.state = 105
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.DOT:
+                self.state = 102
+                self.match(OmegaConfGrammarParser.DOT)
+                self.state = 107
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 113
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.INTER_KEY]:
+                self.state = 108
+                self.configKey()
+                pass
+            elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                self.state = 109
+                self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+                self.state = 110
+                self.configKey()
+                self.state = 111
+                self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 123
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.BRACKET_OPEN or _la==OmegaConfGrammarParser.DOT:
+                self.state = 121
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.DOT]:
+                    self.state = 115
+                    self.match(OmegaConfGrammarParser.DOT)
+                    self.state = 116
+                    self.configKey()
+                    pass
+                elif token in [OmegaConfGrammarParser.BRACKET_OPEN]:
+                    self.state = 117
+                    self.match(OmegaConfGrammarParser.BRACKET_OPEN)
+                    self.state = 118
+                    self.configKey()
+                    self.state = 119
+                    self.match(OmegaConfGrammarParser.BRACKET_CLOSE)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 125
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 126
+            self.match(OmegaConfGrammarParser.INTER_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class InterpolationResolverContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def INTER_OPEN(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0)
+
+        def resolverName(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.ResolverNameContext,0)
+
+
+        def COLON(self):
+            return self.getToken(OmegaConfGrammarParser.COLON, 0)
+
+        def BRACE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0)
+
+        def sequence(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_interpolationResolver
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterInterpolationResolver" ):
+                listener.enterInterpolationResolver(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitInterpolationResolver" ):
+                listener.exitInterpolationResolver(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitInterpolationResolver" ):
+                return visitor.visitInterpolationResolver(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def interpolationResolver(self):
+
+        localctx = OmegaConfGrammarParser.InterpolationResolverContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 20, self.RULE_interpolationResolver)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 128
+            self.match(OmegaConfGrammarParser.INTER_OPEN)
+            self.state = 129
+            self.resolverName()
+            self.state = 130
+            self.match(OmegaConfGrammarParser.COLON)
+            self.state = 132
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0):
+                self.state = 131
+                self.sequence()
+
+
+            self.state = 134
+            self.match(OmegaConfGrammarParser.BRACE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ConfigKeyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,0)
+
+
+        def ID(self):
+            return self.getToken(OmegaConfGrammarParser.ID, 0)
+
+        def INTER_KEY(self):
+            return self.getToken(OmegaConfGrammarParser.INTER_KEY, 0)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_configKey
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterConfigKey" ):
+                listener.enterConfigKey(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitConfigKey" ):
+                listener.exitConfigKey(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConfigKey" ):
+                return visitor.visitConfigKey(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def configKey(self):
+
+        localctx = OmegaConfGrammarParser.ConfigKeyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 22, self.RULE_configKey)
+        try:
+            self.state = 139
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 136
+                self.interpolation()
+                pass
+            elif token in [OmegaConfGrammarParser.ID]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 137
+                self.match(OmegaConfGrammarParser.ID)
+                pass
+            elif token in [OmegaConfGrammarParser.INTER_KEY]:
+                self.enterOuterAlt(localctx, 3)
+                self.state = 138
+                self.match(OmegaConfGrammarParser.INTER_KEY)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ResolverNameContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def DOT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.DOT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.DOT, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_resolverName
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterResolverName" ):
+                listener.enterResolverName(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitResolverName" ):
+                listener.exitResolverName(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitResolverName" ):
+                return visitor.visitResolverName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def resolverName(self):
+
+        localctx = OmegaConfGrammarParser.ResolverNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_resolverName)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 143
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                self.state = 141
+                self.interpolation()
+                pass
+            elif token in [OmegaConfGrammarParser.ID]:
+                self.state = 142
+                self.match(OmegaConfGrammarParser.ID)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 152
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==OmegaConfGrammarParser.DOT:
+                self.state = 145
+                self.match(OmegaConfGrammarParser.DOT)
+                self.state = 148
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 146
+                    self.interpolation()
+                    pass
+                elif token in [OmegaConfGrammarParser.ID]:
+                    self.state = 147
+                    self.match(OmegaConfGrammarParser.ID)
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 154
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class QuotedValueContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def MATCHING_QUOTE_CLOSE(self):
+            return self.getToken(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE, 0)
+
+        def QUOTE_OPEN_SINGLE(self):
+            return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, 0)
+
+        def QUOTE_OPEN_DOUBLE(self):
+            return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, 0)
+
+        def text(self):
+            return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_quotedValue
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterQuotedValue" ):
+                listener.enterQuotedValue(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitQuotedValue" ):
+                listener.exitQuotedValue(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitQuotedValue" ):
+                return visitor.visitQuotedValue(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def quotedValue(self):
+
+        localctx = OmegaConfGrammarParser.QuotedValueContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_quotedValue)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 155
+            _la = self._input.LA(1)
+            if not(_la==OmegaConfGrammarParser.QUOTE_OPEN_SINGLE or _la==OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
+            self.state = 157
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0):
+                self.state = 156
+                self.text()
+
+
+            self.state = 159
+            self.match(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class PrimitiveContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def NULL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.NULL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.NULL, i)
+
+        def INT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.INT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.INT, i)
+
+        def FLOAT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.FLOAT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.FLOAT, i)
+
+        def BOOL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BOOL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BOOL, i)
+
+        def UNQUOTED_CHAR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i)
+
+        def COLON(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.COLON)
+            else:
+                return self.getToken(OmegaConfGrammarParser.COLON, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.WS)
+            else:
+                return self.getToken(OmegaConfGrammarParser.WS, i)
+
+        def interpolation(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext)
+            else:
+                return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i)
+
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_primitive
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterPrimitive" ):
+                listener.enterPrimitive(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitPrimitive" ):
+                listener.exitPrimitive(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPrimitive" ):
+                return visitor.visitPrimitive(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def primitive(self):
+
+        localctx = OmegaConfGrammarParser.PrimitiveContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 28, self.RULE_primitive)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 171 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 171
+                self._errHandler.sync(self)
+                token = self._input.LA(1)
+                if token in [OmegaConfGrammarParser.ID]:
+                    self.state = 161
+                    self.match(OmegaConfGrammarParser.ID)
+                    pass
+                elif token in [OmegaConfGrammarParser.NULL]:
+                    self.state = 162
+                    self.match(OmegaConfGrammarParser.NULL)
+                    pass
+                elif token in [OmegaConfGrammarParser.INT]:
+                    self.state = 163
+                    self.match(OmegaConfGrammarParser.INT)
+                    pass
+                elif token in [OmegaConfGrammarParser.FLOAT]:
+                    self.state = 164
+                    self.match(OmegaConfGrammarParser.FLOAT)
+                    pass
+                elif token in [OmegaConfGrammarParser.BOOL]:
+                    self.state = 165
+                    self.match(OmegaConfGrammarParser.BOOL)
+                    pass
+                elif token in [OmegaConfGrammarParser.UNQUOTED_CHAR]:
+                    self.state = 166
+                    self.match(OmegaConfGrammarParser.UNQUOTED_CHAR)
+                    pass
+                elif token in [OmegaConfGrammarParser.COLON]:
+                    self.state = 167
+                    self.match(OmegaConfGrammarParser.COLON)
+                    pass
+                elif token in [OmegaConfGrammarParser.ESC]:
+                    self.state = 168
+                    self.match(OmegaConfGrammarParser.ESC)
+                    pass
+                elif token in [OmegaConfGrammarParser.WS]:
+                    self.state = 169
+                    self.match(OmegaConfGrammarParser.WS)
+                    pass
+                elif token in [OmegaConfGrammarParser.INTER_OPEN]:
+                    self.state = 170
+                    self.interpolation()
+                    pass
+                else:
+                    raise NoViableAltException(self)
+
+                self.state = 173 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DictKeyContext(ParserRuleContext):
+        __slots__ = 'parser'
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def ID(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ID)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ID, i)
+
+        def NULL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.NULL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.NULL, i)
+
+        def INT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.INT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.INT, i)
+
+        def FLOAT(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.FLOAT)
+            else:
+                return self.getToken(OmegaConfGrammarParser.FLOAT, i)
+
+        def BOOL(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.BOOL)
+            else:
+                return self.getToken(OmegaConfGrammarParser.BOOL, i)
+
+        def UNQUOTED_CHAR(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR)
+            else:
+                return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i)
+
+        def ESC(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.ESC)
+            else:
+                return self.getToken(OmegaConfGrammarParser.ESC, i)
+
+        def WS(self, i:int=None):
+            if i is None:
+                return self.getTokens(OmegaConfGrammarParser.WS)
+            else:
+                return self.getToken(OmegaConfGrammarParser.WS, i)
+
+        def getRuleIndex(self):
+            return OmegaConfGrammarParser.RULE_dictKey
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterDictKey" ):
+                listener.enterDictKey(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitDictKey" ):
+                listener.exitDictKey(self)
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitDictKey" ):
+                return visitor.visitDictKey(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def dictKey(self):
+
+        localctx = OmegaConfGrammarParser.DictKeyContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 30, self.RULE_dictKey)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 176 
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while True:
+                self.state = 175
+                _la = self._input.LA(1)
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    self._errHandler.recoverInline(self)
+                else:
+                    self._errHandler.reportMatch(self)
+                    self.consume()
+                self.state = 178 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)):
+                    break
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+
+
+

mantis_evalkit/lib/python3.10/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserListener.py

@@ -0,0 +1,156 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .OmegaConfGrammarParser import OmegaConfGrammarParser
+else:
+    from OmegaConfGrammarParser import OmegaConfGrammarParser
+
+# This class defines a complete listener for a parse tree produced by OmegaConfGrammarParser.
+class OmegaConfGrammarParserListener(ParseTreeListener):
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#configValue.
+    def enterConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#configValue.
+    def exitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def enterSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def exitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#text.
+    def enterText(self, ctx:OmegaConfGrammarParser.TextContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#text.
+    def exitText(self, ctx:OmegaConfGrammarParser.TextContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#element.
+    def enterElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#element.
+    def exitElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def enterListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def exitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def enterDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def exitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def enterDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def exitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#sequence.
+    def enterSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#sequence.
+    def exitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def enterInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def exitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def enterInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def exitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def enterInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def exitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#configKey.
+    def enterConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#configKey.
+    def exitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def enterResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def exitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def enterQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def exitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#primitive.
+    def enterPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#primitive.
+    def exitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        pass
+
+
+    # Enter a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def enterDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        pass
+
+    # Exit a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def exitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        pass
+
+
+
+del OmegaConfGrammarParser

mantis_evalkit/lib/python3.10/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py

@@ -0,0 +1,93 @@
+# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .OmegaConfGrammarParser import OmegaConfGrammarParser
+else:
+    from OmegaConfGrammarParser import OmegaConfGrammarParser
+
+# This class defines a complete generic visitor for a parse tree produced by OmegaConfGrammarParser.
+
+class OmegaConfGrammarParserVisitor(ParseTreeVisitor):
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#configValue.
+    def visitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#singleElement.
+    def visitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#text.
+    def visitText(self, ctx:OmegaConfGrammarParser.TextContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#element.
+    def visitElement(self, ctx:OmegaConfGrammarParser.ElementContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#listContainer.
+    def visitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictContainer.
+    def visitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair.
+    def visitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#sequence.
+    def visitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolation.
+    def visitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolationNode.
+    def visitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#interpolationResolver.
+    def visitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#configKey.
+    def visitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#resolverName.
+    def visitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#quotedValue.
+    def visitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#primitive.
+    def visitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by OmegaConfGrammarParser#dictKey.
+    def visitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext):
+        return self.visitChildren(ctx)
+
+
+
+del OmegaConfGrammarParser