diff --git a/.gitattributes b/.gitattributes
index 0c6f7f8b3140d67c1dee2803fb5b059e4019d6c1..7c8495ad770360bf8e8b65845f6dc6a21fb6ccbf 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -3478,3 +3478,14 @@ platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/io/__pycach
 platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/io/__pycache__/test_stata.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/io/json/__pycache__/test_pandas.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/io/formats/__pycache__/test_format.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_arithmetic.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_constructors.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_reductions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_stack_unstack.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_indexing.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_inference.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_datetime_index.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..49d088214505b9604964ab142e7f8a5b38ccd5ef
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+from argparse import _SubParsersAction
+
+
+class BaseHuggingfaceCLICommand(ABC):
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(parser: _SubParsersAction):
+        raise NotImplementedError()
+
+    @abstractmethod
+    def run(self):
+        raise NotImplementedError()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/_cli_utils.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/_cli_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbf17e887e901e58461b09e6648d614bb2caabbb
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/_cli_utils.py
@@ -0,0 +1,63 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains a utility for good-looking prints."""
+import os
+from typing import List, Union
+
+
+class ANSI:
+    """
+    Helper for en.wikipedia.org/wiki/ANSI_escape_code
+    """
+
+    _bold = "\u001b[1m"
+    _gray = "\u001b[90m"
+    _red = "\u001b[31m"
+    _reset = "\u001b[0m"
+
+    @classmethod
+    def bold(cls, s: str) -> str:
+        return cls._format(s, cls._bold)
+
+    @classmethod
+    def gray(cls, s: str) -> str:
+        return cls._format(s, cls._gray)
+
+    @classmethod
+    def red(cls, s: str) -> str:
+        return cls._format(s, cls._bold + cls._red)
+
+    @classmethod
+    def _format(cls, s: str, code: str) -> str:
+        if os.environ.get("NO_COLOR"):
+            # See https://no-color.org/
+            return s
+        return f"{code}{s}{cls._reset}"
+
+
+def tabulate(rows: List[List[Union[str, int]]], headers: List[str]) -> str:
+    """
+    Inspired by:
+
+    - stackoverflow.com/a/8356620/593036
+    - stackoverflow.com/questions/9535954/printing-lists-as-tabular-data
+    """
+    col_widths = [max(len(str(x)) for x in col) for col in zip(*rows, headers)]
+    row_format = ("{{:{}}} " * len(headers)).format(*col_widths)
+    lines = []
+    lines.append(row_format.format(*headers))
+    lines.append(row_format.format(*["-" * w for w in col_widths]))
+    for row in rows:
+        lines.append(row_format.format(*row))
+    return "\n".join(lines)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/delete_cache.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/delete_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..c61863f55d3cde2773e4b0e14988514d9c476b01
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/delete_cache.py
@@ -0,0 +1,427 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to delete some revisions from the HF cache directory.
+
+Usage:
+    huggingface-cli delete-cache
+    huggingface-cli delete-cache --disable-tui
+    huggingface-cli delete-cache --dir ~/.cache/huggingface/hub
+
+NOTE:
+    This command is based on `InquirerPy` to build the multiselect menu in the terminal.
+    This dependency has to be installed with `pip install huggingface_hub[cli]`. Since
+    we want to avoid as much as possible cross-platform issues, I chose a library that
+    is built on top of `python-prompt-toolkit` which seems to be a reference in terminal
+    GUI (actively maintained on both Unix and Windows, 7.9k stars).
+
+    For the moment, the TUI feature is in beta.
+
+    See:
+    - https://github.com/kazhala/InquirerPy
+    - https://inquirerpy.readthedocs.io/en/latest/
+    - https://github.com/prompt-toolkit/python-prompt-toolkit
+
+    Other solutions could have been:
+    - `simple_term_menu`: would be good as well for our use case but some issues suggest
+      that Windows is less supported.
+      See: https://github.com/IngoMeyer441/simple-term-menu
+    - `PyInquirer`: very similar to `InquirerPy` but older and not maintained anymore.
+      In particular, no support of Python3.10.
+      See: https://github.com/CITGuru/PyInquirer
+    - `pick` (or `pickpack`): easy to use and flexible but built on top of Python's
+      standard library `curses` that is specific to Unix (not implemented on Windows).
+      See https://github.com/wong2/pick and https://github.com/anafvana/pickpack.
+    - `inquirer`: lot of traction (700 stars) but explicitly states "experimental
+      support of Windows". Not built on top of `python-prompt-toolkit`.
+      See https://github.com/magmax/python-inquirer
+
+TODO: add support for `huggingface-cli delete-cache aaaaaa bbbbbb cccccc (...)` ?
+TODO: add "--keep-last" arg to delete revisions that are not on `main` ref
+TODO: add "--filter" arg to filter repositories by name ?
+TODO: add "--sort" arg to sort by size ?
+TODO: add "--limit" arg to limit to X repos ?
+TODO: add "-y" arg for immediate deletion ?
+See discussions in https://github.com/huggingface/huggingface_hub/issues/1025.
+"""
+import os
+from argparse import Namespace, _SubParsersAction
+from functools import wraps
+from tempfile import mkstemp
+from typing import Any, Callable, Iterable, List, Optional, Union
+
+from ..utils import CachedRepoInfo, CachedRevisionInfo, HFCacheInfo, scan_cache_dir
+from . import BaseHuggingfaceCLICommand
+from ._cli_utils import ANSI
+
+
+try:
+    from InquirerPy import inquirer
+    from InquirerPy.base.control import Choice
+    from InquirerPy.separator import Separator
+
+    _inquirer_py_available = True
+except ImportError:
+    _inquirer_py_available = False
+
+
+def require_inquirer_py(fn: Callable) -> Callable:
+    """Decorator to flag methods that require `InquirerPy`."""
+
+    # TODO: refactor this + imports in a unified pattern across codebase
+    @wraps(fn)
+    def _inner(*args, **kwargs):
+        if not _inquirer_py_available:
+            raise ImportError(
+                "The `delete-cache` command requires extra dependencies to work with"
+                " the TUI.\nPlease run `pip install huggingface_hub[cli]` to install"
+                " them.\nOtherwise, disable TUI using the `--disable-tui` flag."
+            )
+
+        return fn(*args, **kwargs)
+
+    return _inner
+
+
+# Possibility for the user to cancel deletion
+_CANCEL_DELETION_STR = "CANCEL_DELETION"
+
+
+class DeleteCacheCommand(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        delete_cache_parser = parser.add_parser("delete-cache", help="Delete revisions from the cache directory.")
+
+        delete_cache_parser.add_argument(
+            "--dir",
+            type=str,
+            default=None,
+            help="cache directory (optional). Default to the default HuggingFace cache.",
+        )
+
+        delete_cache_parser.add_argument(
+            "--disable-tui",
+            action="store_true",
+            help=(
+                "Disable Terminal User Interface (TUI) mode. Useful if your"
+                " platform/terminal doesn't support the multiselect menu."
+            ),
+        )
+
+        delete_cache_parser.set_defaults(func=DeleteCacheCommand)
+
+    def __init__(self, args: Namespace) -> None:
+        self.cache_dir: Optional[str] = args.dir
+        self.disable_tui: bool = args.disable_tui
+
+    def run(self):
+        """Run `delete-cache` command with or without TUI."""
+        # Scan cache directory
+        hf_cache_info = scan_cache_dir(self.cache_dir)
+
+        # Manual review from the user
+        if self.disable_tui:
+            selected_hashes = _manual_review_no_tui(hf_cache_info, preselected=[])
+        else:
+            selected_hashes = _manual_review_tui(hf_cache_info, preselected=[])
+
+        # If deletion is not cancelled
+        if len(selected_hashes) > 0 and _CANCEL_DELETION_STR not in selected_hashes:
+            confirm_message = _get_expectations_str(hf_cache_info, selected_hashes) + " Confirm deletion ?"
+
+            # Confirm deletion
+            if self.disable_tui:
+                confirmed = _ask_for_confirmation_no_tui(confirm_message)
+            else:
+                confirmed = _ask_for_confirmation_tui(confirm_message)
+
+            # Deletion is confirmed
+            if confirmed:
+                strategy = hf_cache_info.delete_revisions(*selected_hashes)
+                print("Start deletion.")
+                strategy.execute()
+                print(
+                    f"Done. Deleted {len(strategy.repos)} repo(s) and"
+                    f" {len(strategy.snapshots)} revision(s) for a total of"
+                    f" {strategy.expected_freed_size_str}."
+                )
+                return
+
+        # Deletion is cancelled
+        print("Deletion is cancelled. Do nothing.")
+
+
+@require_inquirer_py
+def _manual_review_tui(hf_cache_info: HFCacheInfo, preselected: List[str]) -> List[str]:
+    """Ask the user for a manual review of the revisions to delete.
+
+    Displays a multi-select menu in the terminal (TUI).
+    """
+    # Define multiselect list
+    choices = _get_tui_choices_from_scan(repos=hf_cache_info.repos, preselected=preselected)
+    checkbox = inquirer.checkbox(
+        message="Select revisions to delete:",
+        choices=choices,  # List of revisions with some pre-selection
+        cycle=False,  # No loop between top and bottom
+        height=100,  # Large list if possible
+        # We use the instruction to display to the user the expected effect of the
+        # deletion.
+        instruction=_get_expectations_str(
+            hf_cache_info,
+            selected_hashes=[c.value for c in choices if isinstance(c, Choice) and c.enabled],
+        ),
+        # We use the long instruction to should keybindings instructions to the user
+        long_instruction="Press <space> to select, <enter> to validate and <ctrl+c> to quit without modification.",
+        # Message that is displayed once the user validates its selection.
+        transformer=lambda result: f"{len(result)} revision(s) selected.",
+    )
+
+    # Add a callback to update the information line when a revision is
+    # selected/unselected
+    def _update_expectations(_) -> None:
+        # Hacky way to dynamically set an instruction message to the checkbox when
+        # a revision hash is selected/unselected.
+        checkbox._instruction = _get_expectations_str(
+            hf_cache_info,
+            selected_hashes=[choice["value"] for choice in checkbox.content_control.choices if choice["enabled"]],
+        )
+
+    checkbox.kb_func_lookup["toggle"].append({"func": _update_expectations})
+
+    # Finally display the form to the user.
+    try:
+        return checkbox.execute()
+    except KeyboardInterrupt:
+        return []  # Quit without deletion
+
+
+@require_inquirer_py
+def _ask_for_confirmation_tui(message: str, default: bool = True) -> bool:
+    """Ask for confirmation using Inquirer."""
+    return inquirer.confirm(message, default=default).execute()
+
+
+def _get_tui_choices_from_scan(repos: Iterable[CachedRepoInfo], preselected: List[str]) -> List:
+    """Build a list of choices from the scanned repos.
+
+    Args:
+        repos (*Iterable[`CachedRepoInfo`]*):
+            List of scanned repos on which we want to delete revisions.
+        preselected (*List[`str`]*):
+            List of revision hashes that will be preselected.
+
+    Return:
+        The list of choices to pass to `inquirer.checkbox`.
+    """
+    choices: List[Union[Choice, Separator]] = []
+
+    # First choice is to cancel the deletion. If selected, nothing will be deleted,
+    # no matter the other selected items.
+    choices.append(
+        Choice(
+            _CANCEL_DELETION_STR,
+            name="None of the following (if selected, nothing will be deleted).",
+            enabled=False,
+        )
+    )
+
+    # Display a separator per repo and a Choice for each revisions of the repo
+    for repo in sorted(repos, key=_repo_sorting_order):
+        # Repo as separator
+        choices.append(
+            Separator(
+                f"\n{repo.repo_type.capitalize()} {repo.repo_id} ({repo.size_on_disk_str},"
+                f" used {repo.last_accessed_str})"
+            )
+        )
+        for revision in sorted(repo.revisions, key=_revision_sorting_order):
+            # Revision as choice
+            choices.append(
+                Choice(
+                    revision.commit_hash,
+                    name=(
+                        f"{revision.commit_hash[:8]}:"
+                        f" {', '.join(sorted(revision.refs)) or '(detached)'} #"
+                        f" modified {revision.last_modified_str}"
+                    ),
+                    enabled=revision.commit_hash in preselected,
+                )
+            )
+
+    # Return choices
+    return choices
+
+
+def _manual_review_no_tui(hf_cache_info: HFCacheInfo, preselected: List[str]) -> List[str]:
+    """Ask the user for a manual review of the revisions to delete.
+
+    Used when TUI is disabled. Manual review happens in a separate tmp file that the
+    user can manually edit.
+    """
+    # 1. Generate temporary file with delete commands.
+    fd, tmp_path = mkstemp(suffix=".txt")  # suffix to make it easier to find by editors
+    os.close(fd)
+
+    lines = []
+    for repo in sorted(hf_cache_info.repos, key=_repo_sorting_order):
+        lines.append(
+            f"\n# {repo.repo_type.capitalize()} {repo.repo_id} ({repo.size_on_disk_str},"
+            f" used {repo.last_accessed_str})"
+        )
+        for revision in sorted(repo.revisions, key=_revision_sorting_order):
+            lines.append(
+                # Deselect by prepending a '#'
+                f"{'' if revision.commit_hash in preselected else '#'}   "
+                f" {revision.commit_hash} # Refs:"
+                # Print `refs` as comment on same line
+                f" {', '.join(sorted(revision.refs)) or '(detached)'} # modified"
+                # Print `last_modified` as comment on same line
+                f" {revision.last_modified_str}"
+            )
+
+    with open(tmp_path, "w") as f:
+        f.write(_MANUAL_REVIEW_NO_TUI_INSTRUCTIONS)
+        f.write("\n".join(lines))
+
+    # 2. Prompt instructions to user.
+    instructions = f"""
+    TUI is disabled. In order to select which revisions you want to delete, please edit
+    the following file using the text editor of your choice. Instructions for manual
+    editing are located at the beginning of the file. Edit the file, save it and confirm
+    to continue.
+    File to edit: {ANSI.bold(tmp_path)}
+    """
+    print("\n".join(line.strip() for line in instructions.strip().split("\n")))
+
+    # 3. Wait for user confirmation.
+    while True:
+        selected_hashes = _read_manual_review_tmp_file(tmp_path)
+        if _ask_for_confirmation_no_tui(
+            _get_expectations_str(hf_cache_info, selected_hashes) + " Continue ?",
+            default=False,
+        ):
+            break
+
+    # 4. Return selected_hashes
+    os.remove(tmp_path)
+    return selected_hashes
+
+
+def _ask_for_confirmation_no_tui(message: str, default: bool = True) -> bool:
+    """Ask for confirmation using pure-python."""
+    YES = ("y", "yes", "1")
+    NO = ("n", "no", "0")
+    DEFAULT = ""
+    ALL = YES + NO + (DEFAULT,)
+    full_message = message + (" (Y/n) " if default else " (y/N) ")
+    while True:
+        answer = input(full_message).lower()
+        if answer == DEFAULT:
+            return default
+        if answer in YES:
+            return True
+        if answer in NO:
+            return False
+        print(f"Invalid input. Must be one of {ALL}")
+
+
+def _get_expectations_str(hf_cache_info: HFCacheInfo, selected_hashes: List[str]) -> str:
+    """Format a string to display to the user how much space would be saved.
+
+    Example:
+    ```
+    >>> _get_expectations_str(hf_cache_info, selected_hashes)
+    '7 revisions selected counting for 4.3G.'
+    ```
+    """
+    if _CANCEL_DELETION_STR in selected_hashes:
+        return "Nothing will be deleted."
+    strategy = hf_cache_info.delete_revisions(*selected_hashes)
+    return f"{len(selected_hashes)} revisions selected counting for {strategy.expected_freed_size_str}."
+
+
+def _read_manual_review_tmp_file(tmp_path: str) -> List[str]:
+    """Read the manually reviewed instruction file and return a list of revision hash.
+
+    Example:
+        ```txt
+        # This is the tmp file content
+        ###
+
+        # Commented out line
+        123456789 # revision hash
+
+        # Something else
+        #      a_newer_hash # 2 days ago
+            an_older_hash # 3 days ago
+        ```
+
+        ```py
+        >>> _read_manual_review_tmp_file(tmp_path)
+        ['123456789', 'an_older_hash']
+        ```
+    """
+    with open(tmp_path) as f:
+        content = f.read()
+
+    # Split lines
+    lines = [line.strip() for line in content.split("\n")]
+
+    # Filter commented lines
+    selected_lines = [line for line in lines if not line.startswith("#")]
+
+    # Select only before comment
+    selected_hashes = [line.split("#")[0].strip() for line in selected_lines]
+
+    # Return revision hashes
+    return [hash for hash in selected_hashes if len(hash) > 0]
+
+
+_MANUAL_REVIEW_NO_TUI_INSTRUCTIONS = f"""
+# INSTRUCTIONS
+# ------------
+# This is a temporary file created by running `huggingface-cli delete-cache` with the
+# `--disable-tui` option. It contains a set of revisions that can be deleted from your
+# local cache directory.
+#
+# Please manually review the revisions you want to delete:
+#   - Revision hashes can be commented out with '#'.
+#   - Only non-commented revisions in this file will be deleted.
+#   - Revision hashes that are removed from this file are ignored as well.
+#   - If `{_CANCEL_DELETION_STR}` line is uncommented, the all cache deletion is cancelled and
+#     no changes will be applied.
+#
+# Once you've manually reviewed this file, please confirm deletion in the terminal. This
+# file will be automatically removed once done.
+# ------------
+
+# KILL SWITCH
+# ------------
+# Un-comment following line to completely cancel the deletion process
+# {_CANCEL_DELETION_STR}
+# ------------
+
+# REVISIONS
+# ------------
+""".strip()
+
+
+def _repo_sorting_order(repo: CachedRepoInfo) -> Any:
+    # First split by Dataset/Model, then sort by last accessed (oldest first)
+    return (repo.repo_type, repo.last_accessed)
+
+
+def _revision_sorting_order(revision: CachedRevisionInfo) -> Any:
+    # Sort by last modified (oldest first)
+    return revision.last_modified
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/download.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/download.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ac5205e842fcc1e1711333983a40157bb863a7b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/download.py
@@ -0,0 +1,214 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to download files from the Hub with the CLI.
+
+Usage:
+    huggingface-cli download --help
+
+    # Download file
+    huggingface-cli download gpt2 config.json
+
+    # Download entire repo
+    huggingface-cli download fffiloni/zeroscope --repo-type=space --revision=refs/pr/78
+
+    # Download repo with filters
+    huggingface-cli download gpt2 --include="*.safetensors"
+
+    # Download with token
+    huggingface-cli download Wauplin/private-model --token=hf_***
+
+    # Download quietly (no progress bar, no warnings, only the returned path)
+    huggingface-cli download gpt2 config.json --quiet
+
+    # Download to local dir
+    huggingface-cli download gpt2 --local-dir=./models/gpt2
+"""
+import warnings
+from argparse import Namespace, _SubParsersAction
+from typing import List, Literal, Optional, Union
+
+from huggingface_hub import logging
+from huggingface_hub._snapshot_download import snapshot_download
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.constants import HF_HUB_ENABLE_HF_TRANSFER
+from huggingface_hub.file_download import hf_hub_download
+from huggingface_hub.utils import disable_progress_bars, enable_progress_bars
+
+
+logger = logging.get_logger(__name__)
+
+
+class DownloadCommand(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        download_parser = parser.add_parser("download", help="Download files from the Hub")
+        download_parser.add_argument(
+            "repo_id", type=str, help="ID of the repo to download from (e.g. `username/repo-name`)."
+        )
+        download_parser.add_argument(
+            "filenames", type=str, nargs="*", help="Files to download (e.g. `config.json`, `data/metadata.jsonl`)."
+        )
+        download_parser.add_argument(
+            "--repo-type",
+            choices=["model", "dataset", "space"],
+            default="model",
+            help="Type of repo to download from (e.g. `dataset`).",
+        )
+        download_parser.add_argument(
+            "--revision",
+            type=str,
+            help="An optional Git revision id which can be a branch name, a tag, or a commit hash.",
+        )
+        download_parser.add_argument(
+            "--include", nargs="*", type=str, help="Glob patterns to match files to download."
+        )
+        download_parser.add_argument(
+            "--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to download."
+        )
+        download_parser.add_argument(
+            "--cache-dir", type=str, help="Path to the directory where to save the downloaded files."
+        )
+        download_parser.add_argument(
+            "--local-dir",
+            type=str,
+            help=(
+                "If set, the downloaded file will be placed under this directory either as a symlink (default) or a"
+                " regular file. Check out"
+                " https://huggingface.co/docs/huggingface_hub/guides/download#download-files-to-local-folder for more"
+                " details."
+            ),
+        )
+        download_parser.add_argument(
+            "--local-dir-use-symlinks",
+            choices=["auto", "True", "False"],
+            default="auto",
+            help=(
+                "To be used with `local_dir`. If set to 'auto', the cache directory will be used and the file will be"
+                " either duplicated or symlinked to the local directory depending on its size. It set to `True`, a"
+                " symlink will be created, no matter the file size. If set to `False`, the file will either be"
+                " duplicated from cache (if already exists) or downloaded from the Hub and not cached."
+            ),
+        )
+        download_parser.add_argument(
+            "--force-download",
+            action="store_true",
+            help="If True, the files will be downloaded even if they are already cached.",
+        )
+        download_parser.add_argument(
+            "--resume-download", action="store_true", help="If True, resume a previously interrupted download."
+        )
+        download_parser.add_argument(
+            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
+        )
+        download_parser.add_argument(
+            "--quiet",
+            action="store_true",
+            help="If True, progress bars are disabled and only the path to the download files is printed.",
+        )
+        download_parser.set_defaults(func=DownloadCommand)
+
+    def __init__(self, args: Namespace) -> None:
+        self.token = args.token
+        self.repo_id: str = args.repo_id
+        self.filenames: List[str] = args.filenames
+        self.repo_type: str = args.repo_type
+        self.revision: Optional[str] = args.revision
+        self.include: Optional[List[str]] = args.include
+        self.exclude: Optional[List[str]] = args.exclude
+        self.cache_dir: Optional[str] = args.cache_dir
+        self.local_dir: Optional[str] = args.local_dir
+        self.force_download: bool = args.force_download
+        self.resume_download: bool = args.resume_download
+        self.quiet: bool = args.quiet
+
+        # Raise if local_dir_use_symlinks is invalid
+        self.local_dir_use_symlinks: Union[Literal["auto"], bool]
+        use_symlinks_lowercase = args.local_dir_use_symlinks.lower()
+        if use_symlinks_lowercase == "true":
+            self.local_dir_use_symlinks = True
+        elif use_symlinks_lowercase == "false":
+            self.local_dir_use_symlinks = False
+        elif use_symlinks_lowercase == "auto":
+            self.local_dir_use_symlinks = "auto"
+        else:
+            raise ValueError(
+                f"'{args.local_dir_use_symlinks}' is not a valid value for `local_dir_use_symlinks`. It must be either"
+                " 'auto', 'True' or 'False'."
+            )
+
+    def run(self) -> None:
+        if self.quiet:
+            disable_progress_bars()
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                print(self._download())  # Print path to downloaded files
+            enable_progress_bars()
+        else:
+            logging.set_verbosity_info()
+            print(self._download())  # Print path to downloaded files
+            logging.set_verbosity_warning()
+
+    def _download(self) -> str:
+        # Warn user if patterns are ignored
+        if len(self.filenames) > 0:
+            if self.include is not None and len(self.include) > 0:
+                warnings.warn("Ignoring `--include` since filenames have being explicitly set.")
+            if self.exclude is not None and len(self.exclude) > 0:
+                warnings.warn("Ignoring `--exclude` since filenames have being explicitly set.")
+
+        if not HF_HUB_ENABLE_HF_TRANSFER:
+            logger.info(
+                "Consider using `hf_transfer` for faster downloads. This solution comes with some limitations. See"
+                " https://huggingface.co/docs/huggingface_hub/hf_transfer for more details."
+            )
+
+        # Single file to download: use `hf_hub_download`
+        if len(self.filenames) == 1:
+            return hf_hub_download(
+                repo_id=self.repo_id,
+                repo_type=self.repo_type,
+                revision=self.revision,
+                filename=self.filenames[0],
+                cache_dir=self.cache_dir,
+                resume_download=self.resume_download,
+                force_download=self.force_download,
+                token=self.token,
+                local_dir=self.local_dir,
+                local_dir_use_symlinks=self.local_dir_use_symlinks,
+                library_name="huggingface-cli",
+            )
+
+        # Otherwise: use `snapshot_download` to ensure all files comes from same revision
+        elif len(self.filenames) == 0:
+            allow_patterns = self.include
+            ignore_patterns = self.exclude
+        else:
+            allow_patterns = self.filenames
+            ignore_patterns = None
+
+        return snapshot_download(
+            repo_id=self.repo_id,
+            repo_type=self.repo_type,
+            revision=self.revision,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            resume_download=self.resume_download,
+            force_download=self.force_download,
+            cache_dir=self.cache_dir,
+            token=self.token,
+            local_dir=self.local_dir,
+            local_dir_use_symlinks=self.local_dir_use_symlinks,
+            library_name="huggingface-cli",
+        )
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/env.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/env.py
new file mode 100644
index 0000000000000000000000000000000000000000..26d0d7fb151125703d5a0c84fa5d78d68f1eb8d8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/huggingface_hub/commands/env.py
@@ -0,0 +1,35 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to print information about the environment.
+
+Usage:
+    huggingface-cli env
+"""
+from argparse import _SubParsersAction
+
+from ..utils import dump_environment_info
+from . import BaseHuggingfaceCLICommand
+
+
+class EnvironmentCommand(BaseHuggingfaceCLICommand):
+    def __init__(self, args):
+        self.args = args
+
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        env_parser = parser.add_parser("env", help="Print information about the environment.")
+        env_parser.set_defaults(func=EnvironmentCommand)
+
+    def run(self) -> None:
+        dump_environment_info()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications-2025.4.1.dist-info/licenses/COPYING b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications-2025.4.1.dist-info/licenses/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..a9f853e43069b8e3f8a156a4af2b1198a004230d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications-2025.4.1.dist-info/licenses/COPYING
@@ -0,0 +1,19 @@
+Copyright (c) 2022 Julian Berman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1bf2751487d75becf30327f7c806ad0e5c16cb8d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/__pycache__/_core.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/__pycache__/_core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9febeced53faa2eb1c3bf6342c44a01f2bb43956
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/__pycache__/_core.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/metaschema.json b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/metaschema.json
new file mode 100644
index 0000000000000000000000000000000000000000..2248a0c80bbfc51b67863f848f60466f135cdb2b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/metaschema.json
@@ -0,0 +1,42 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/core": true,
+        "https://json-schema.org/draft/2019-09/vocab/applicator": true,
+        "https://json-schema.org/draft/2019-09/vocab/validation": true,
+        "https://json-schema.org/draft/2019-09/vocab/meta-data": true,
+        "https://json-schema.org/draft/2019-09/vocab/format": false,
+        "https://json-schema.org/draft/2019-09/vocab/content": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Core and Validation specifications meta-schema",
+    "allOf": [
+        {"$ref": "meta/core"},
+        {"$ref": "meta/applicator"},
+        {"$ref": "meta/validation"},
+        {"$ref": "meta/meta-data"},
+        {"$ref": "meta/format"},
+        {"$ref": "meta/content"}
+    ],
+    "type": ["object", "boolean"],
+    "properties": {
+        "definitions": {
+            "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "$comment": "\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"",
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$recursiveRef": "#" },
+                    { "$ref": "meta/validation#/$defs/stringArray" }
+                ]
+            }
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator
new file mode 100644
index 0000000000000000000000000000000000000000..24a1cc4f4f54b5a556de93c2799853b31e78e512
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/applicator
@@ -0,0 +1,56 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/applicator": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "additionalItems": { "$recursiveRef": "#" },
+        "unevaluatedItems": { "$recursiveRef": "#" },
+        "items": {
+            "anyOf": [
+                { "$recursiveRef": "#" },
+                { "$ref": "#/$defs/schemaArray" }
+            ]
+        },
+        "contains": { "$recursiveRef": "#" },
+        "additionalProperties": { "$recursiveRef": "#" },
+        "unevaluatedProperties": { "$recursiveRef": "#" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": {
+                "$recursiveRef": "#"
+            }
+        },
+        "propertyNames": { "$recursiveRef": "#" },
+        "if": { "$recursiveRef": "#" },
+        "then": { "$recursiveRef": "#" },
+        "else": { "$recursiveRef": "#" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$recursiveRef": "#" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$recursiveRef": "#" }
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content
new file mode 100644
index 0000000000000000000000000000000000000000..f6752a8efbeb74a7b7b2e74cbb272c422a975363
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/content
@@ -0,0 +1,17 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/content",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/content": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "contentSchema": { "$recursiveRef": "#" }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core
new file mode 100644
index 0000000000000000000000000000000000000000..eb708a56044146bb7903fd59159725a0c693aefe
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/core
@@ -0,0 +1,57 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/core",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/core": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$anchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveRef": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveAnchor": {
+            "type": "boolean",
+            "default": false
+        },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": {
+                "type": "string",
+                "format": "uri"
+            },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/meta-data b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/meta-data
new file mode 100644
index 0000000000000000000000000000000000000000..da04cff6d346f26bfe5bd21b636609fecd583628
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/meta-data
@@ -0,0 +1,37 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/meta-data",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/meta-data": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Meta-data vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "deprecated": {
+            "type": "boolean",
+            "default": false
+        },
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation
new file mode 100644
index 0000000000000000000000000000000000000000..9f59677b30c238f07a358c0c8ee72c3b710dc24d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft201909/vocabularies/validation
@@ -0,0 +1,98 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/validation",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/validation": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Validation vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minContains": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 1
+        },
+        "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/$defs/stringArray" },
+        "dependentRequired": {
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/$defs/stringArray"
+            }
+        },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/$defs/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        }
+    },
+    "$defs": {
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 0
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json
new file mode 100644
index 0000000000000000000000000000000000000000..d5e2d31c3c88e61f4c204cb6616887bba7e105dd
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/metaschema.json
@@ -0,0 +1,58 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core and Validation specifications meta-schema",
+    "allOf": [
+        {"$ref": "meta/core"},
+        {"$ref": "meta/applicator"},
+        {"$ref": "meta/unevaluated"},
+        {"$ref": "meta/validation"},
+        {"$ref": "meta/meta-data"},
+        {"$ref": "meta/format-annotation"},
+        {"$ref": "meta/content"}
+    ],
+    "type": ["object", "boolean"],
+    "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+    "properties": {
+        "definitions": {
+            "$comment": "\"definitions\" has been replaced by \"$defs\".",
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "deprecated": true,
+            "default": {}
+        },
+        "dependencies": {
+            "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$dynamicRef": "#meta" },
+                    { "$ref": "meta/validation#/$defs/stringArray" }
+                ]
+            },
+            "deprecated": true,
+            "default": {}
+        },
+        "$recursiveAnchor": {
+            "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+            "$ref": "meta/core#/$defs/anchorString",
+            "deprecated": true
+        },
+        "$recursiveRef": {
+            "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+            "$ref": "meta/core#/$defs/uriReferenceString",
+            "deprecated": true
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/applicator b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/applicator
new file mode 100644
index 0000000000000000000000000000000000000000..ca69923096f3a2e4fe5eb8152a92d87d146cf021
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/applicator
@@ -0,0 +1,48 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "prefixItems": { "$ref": "#/$defs/schemaArray" },
+        "items": { "$dynamicRef": "#meta" },
+        "contains": { "$dynamicRef": "#meta" },
+        "additionalProperties": { "$dynamicRef": "#meta" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        },
+        "propertyNames": { "$dynamicRef": "#meta" },
+        "if": { "$dynamicRef": "#meta" },
+        "then": { "$dynamicRef": "#meta" },
+        "else": { "$dynamicRef": "#meta" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$dynamicRef": "#meta" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$dynamicRef": "#meta" }
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/content b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/content
new file mode 100644
index 0000000000000000000000000000000000000000..2f6e056a9ac2399582eaf05985a26acf9161f213
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/content
@@ -0,0 +1,17 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/content",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentEncoding": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentSchema": { "$dynamicRef": "#meta" }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/core b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/core
new file mode 100644
index 0000000000000000000000000000000000000000..dfc092d9646e1ea89e4d771bfcf2a4ca87eeac75
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/core
@@ -0,0 +1,51 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/core",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "$ref": "#/$defs/uriReferenceString",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": { "$ref": "#/$defs/uriString" },
+        "$ref": { "$ref": "#/$defs/uriReferenceString" },
+        "$anchor": { "$ref": "#/$defs/anchorString" },
+        "$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+        "$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": { "$ref": "#/$defs/uriString" },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" }
+        }
+    },
+    "$defs": {
+        "anchorString": {
+            "type": "string",
+            "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        "uriString": {
+            "type": "string",
+            "format": "uri"
+        },
+        "uriReferenceString": {
+            "type": "string",
+            "format": "uri-reference"
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format
new file mode 100644
index 0000000000000000000000000000000000000000..09bbfdda972ca77cd26e290d70ab59db4bbe8a27
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format
@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/format",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/format": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Format vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation
new file mode 100644
index 0000000000000000000000000000000000000000..51ef7ea118c34e8ac3da66c973bae02b9e8325d8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-annotation
@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for annotation results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-assertion b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-assertion
new file mode 100644
index 0000000000000000000000000000000000000000..5e73fd7571e504990f7a055da960056f07dcdb19
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/format-assertion
@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-assertion": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for assertion results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/meta-data b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/meta-data
new file mode 100644
index 0000000000000000000000000000000000000000..05cbc22afde5ebe6ba84957ca412277bde1e4b08
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/meta-data
@@ -0,0 +1,37 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Meta-data vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "deprecated": {
+            "type": "boolean",
+            "default": false
+        },
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated
new file mode 100644
index 0000000000000000000000000000000000000000..5f62a3ffa20be07dc813d6b8a154fa8451d0dc61
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/unevaluated
@@ -0,0 +1,15 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Unevaluated applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "unevaluatedItems": { "$dynamicRef": "#meta" },
+        "unevaluatedProperties": { "$dynamicRef": "#meta" }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/validation b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/validation
new file mode 100644
index 0000000000000000000000000000000000000000..606b87ba2ec213d63b9e2035a6acc4edcb4b8357
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft202012/vocabularies/validation
@@ -0,0 +1,98 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/validation",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Validation vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "type": {
+            "anyOf": [
+                { "$ref": "#/$defs/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minContains": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 1
+        },
+        "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/$defs/stringArray" },
+        "dependentRequired": {
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/$defs/stringArray"
+            }
+        }
+    },
+    "$defs": {
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 0
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    }
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft3/metaschema.json b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft3/metaschema.json
new file mode 100644
index 0000000000000000000000000000000000000000..8b26b1f89f9852e4f69f466dd7d718b21ba5b989
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft3/metaschema.json
@@ -0,0 +1,172 @@
+{
+	"$schema" : "http://json-schema.org/draft-03/schema#",
+	"id" : "http://json-schema.org/draft-03/schema#",
+	"type" : "object",
+
+	"properties" : {
+		"type" : {
+			"type" : ["string", "array"],
+			"items" : {
+				"type" : ["string", {"$ref" : "#"}]
+			},
+			"uniqueItems" : true,
+			"default" : "any"
+		},
+
+		"properties" : {
+			"type" : "object",
+			"additionalProperties" : {"$ref" : "#"},
+			"default" : {}
+		},
+
+		"patternProperties" : {
+			"type" : "object",
+			"additionalProperties" : {"$ref" : "#"},
+			"default" : {}
+		},
+
+		"additionalProperties" : {
+			"type" : [{"$ref" : "#"}, "boolean"],
+			"default" : {}
+		},
+
+		"items" : {
+			"type" : [{"$ref" : "#"}, "array"],
+			"items" : {"$ref" : "#"},
+			"default" : {}
+		},
+
+		"additionalItems" : {
+			"type" : [{"$ref" : "#"}, "boolean"],
+			"default" : {}
+		},
+
+		"required" : {
+			"type" : "boolean",
+			"default" : false
+		},
+
+		"dependencies" : {
+			"type" : "object",
+			"additionalProperties" : {
+				"type" : ["string", "array", {"$ref" : "#"}],
+				"items" : {
+					"type" : "string"
+				}
+			},
+			"default" : {}
+		},
+
+		"minimum" : {
+			"type" : "number"
+		},
+
+		"maximum" : {
+			"type" : "number"
+		},
+
+		"exclusiveMinimum" : {
+			"type" : "boolean",
+			"default" : false
+		},
+
+		"exclusiveMaximum" : {
+			"type" : "boolean",
+			"default" : false
+		},
+
+		"minItems" : {
+			"type" : "integer",
+			"minimum" : 0,
+			"default" : 0
+		},
+
+		"maxItems" : {
+			"type" : "integer",
+			"minimum" : 0
+		},
+
+		"uniqueItems" : {
+			"type" : "boolean",
+			"default" : false
+		},
+
+		"pattern" : {
+			"type" : "string",
+			"format" : "regex"
+		},
+
+		"minLength" : {
+			"type" : "integer",
+			"minimum" : 0,
+			"default" : 0
+		},
+
+		"maxLength" : {
+			"type" : "integer"
+		},
+
+		"enum" : {
+			"type" : "array",
+			"minItems" : 1,
+			"uniqueItems" : true
+		},
+
+		"default" : {
+			"type" : "any"
+		},
+
+		"title" : {
+			"type" : "string"
+		},
+
+		"description" : {
+			"type" : "string"
+		},
+
+		"format" : {
+			"type" : "string"
+		},
+
+		"divisibleBy" : {
+			"type" : "number",
+			"minimum" : 0,
+			"exclusiveMinimum" : true,
+			"default" : 1
+		},
+
+		"disallow" : {
+			"type" : ["string", "array"],
+			"items" : {
+				"type" : ["string", {"$ref" : "#"}]
+			},
+			"uniqueItems" : true
+		},
+
+		"extends" : {
+			"type" : [{"$ref" : "#"}, "array"],
+			"items" : {"$ref" : "#"},
+			"default" : {}
+		},
+
+		"id" : {
+			"type" : "string"
+		},
+
+		"$ref" : {
+			"type" : "string"
+		},
+
+		"$schema" : {
+			"type" : "string",
+			"format" : "uri"
+		}
+	},
+
+	"dependencies" : {
+		"exclusiveMinimum" : "minimum",
+		"exclusiveMaximum" : "maximum"
+	},
+
+	"default" : {}
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json
new file mode 100644
index 0000000000000000000000000000000000000000..bcbb84743e3838fab7cbec5f0a5bcbafcfc99136
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft4/metaschema.json
@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json
new file mode 100644
index 0000000000000000000000000000000000000000..a0d2bf7896c2619ae657cd3b3266660156021706
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft6/metaschema.json
@@ -0,0 +1,153 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array"
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json
new file mode 100644
index 0000000000000000000000000000000000000000..746cde9690134529bdcde889f72c7ad5259f24ad
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/schemas/draft7/metaschema.json
@@ -0,0 +1,166 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": true
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "if": {"$ref": "#"},
+        "then": {"$ref": "#"},
+        "else": {"$ref": "#"},
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": true
+}
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78c52c8879186756adfb412235d11fd92b366b54
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__pycache__/test_jsonschema_specifications.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__pycache__/test_jsonschema_specifications.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..689ab2727831b4dc8f26643dc49d342b07a83ef3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/__pycache__/test_jsonschema_specifications.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd2927e0c8381f3eb93029df155758c05ed5eb26
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/jsonschema_specifications/tests/test_jsonschema_specifications.py
@@ -0,0 +1,41 @@
+from collections.abc import Mapping
+from pathlib import Path
+
+import pytest
+
+from jsonschema_specifications import REGISTRY
+
+
+def test_it_contains_metaschemas():
+    schema = REGISTRY.contents("http://json-schema.org/draft-07/schema#")
+    assert isinstance(schema, Mapping)
+    assert schema["$id"] == "http://json-schema.org/draft-07/schema#"
+    assert schema["title"] == "Core schema meta-schema"
+
+
+def test_it_is_crawled():
+    assert REGISTRY.crawl() == REGISTRY
+
+
+@pytest.mark.parametrize(
+    "ignored_relative_path",
+    ["schemas/.DS_Store", "schemas/draft7/.DS_Store"],
+)
+def test_it_copes_with_dotfiles(ignored_relative_path):
+    """
+    Ignore files like .DS_Store if someone has actually caused one to exist.
+
+    We test here through the private interface as of course the global has
+    already loaded our schemas.
+    """
+
+    import jsonschema_specifications
+
+    package = Path(jsonschema_specifications.__file__).parent
+
+    ignored = package / ignored_relative_path
+    ignored.touch()
+    try:
+        list(jsonschema_specifications._schemas())
+    finally:
+        ignored.unlink()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e51ab3d5ff05e50d0882a2088760cdaaaa1d3c4d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/test_config.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/test_config.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd1cafe283caa77ae32f4841c057d413e49ec3d7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/test_config.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/test_localization.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/test_localization.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d543b787c28e07f4b18d1bbbc04d9f83f2ef0de8
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/config/__pycache__/test_localization.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/construction/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/construction/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7658fcca80fa8b8c08c92b8cdd3cc76d647aff51
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/construction/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/construction/__pycache__/test_extract_array.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/construction/__pycache__/test_extract_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a3f5174c096e51bfa973dda43f0d251f59f2eba
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/construction/__pycache__/test_extract_array.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab8efeb1bc35895c85e76ca9f22acb317b590cbc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_array.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..188497e1fd1aaff7ef881d153299e7c7213a2e33
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_array.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_astype.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_astype.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..544172bf1dfafff533304dc79844b14632018c62
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_astype.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_clip.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_clip.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e20ccd4f02380b296332a40ded3995dcca8b4f90
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_clip.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_constructors.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_constructors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0cc9efbe04f475c9c0787c81e73fe69c38d63597
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_constructors.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d665d74da4e46f261b029e297847aecc1be7a173
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_functions.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbbca4f9be95314f6909def428b1a37a245cc7e3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_functions.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_indexing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_indexing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed283e7c9c5614a2a3312d5fcb1aa36d5160541b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_indexing.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_internals.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_internals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..898acfb354c7f75117a72386af440fc5b6ac1202
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_internals.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef775ac2bea498cbdd5b2311c7cad8abf415c89b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af0870326797d2382f40daf7038c8682e9842e80
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1856b271a285dcbcf658ab43a9cc97c508d3d412cbbb5ff13774bc8c6202438
+size 103398
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_replace.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_replace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a1ab8b54d2b608b2a61acbb833f8130a1505628
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_replace.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_setitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_setitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36aa679f7dff25d5999164ab875bc9063dc3aac2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_setitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_util.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01b37eb9b7ef01ee727e0f14e23884c9062ba484
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/test_util.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/util.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ede95377162943d568f756bb1c3b3b5e03a2bb0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/__pycache__/util.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e828fd2ced25e098907a769516d7ea6d37ab844
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_datetimeindex.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_datetimeindex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30475b626d239be0f671f774374e5e0c13373a08
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_datetimeindex.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6852ae81ddbbc1eb30b25b531913c344a74a590f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_periodindex.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_periodindex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e4bb9a36f75489db32f34a52dd4daa0fcc76a0d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_periodindex.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_timedeltaindex.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_timedeltaindex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ea1144b7a16ea1f31e2ce4c195a4cd1bb052d9d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/__pycache__/test_timedeltaindex.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_datetimeindex.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_datetimeindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..f54beca4cc414020a646906e931f4062f714c0e2
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_datetimeindex.py
@@ -0,0 +1,65 @@
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "cons",
+    [
+        lambda x: DatetimeIndex(x),
+        lambda x: DatetimeIndex(DatetimeIndex(x)),
+    ],
+)
+def test_datetimeindex(using_copy_on_write, cons):
+    dt = date_range("2019-12-31", periods=3, freq="D")
+    ser = Series(dt)
+    idx = cons(ser)
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = Timestamp("2020-12-31")
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
+
+
+def test_datetimeindex_tz_convert(using_copy_on_write):
+    dt = date_range("2019-12-31", periods=3, freq="D", tz="Europe/Berlin")
+    ser = Series(dt)
+    idx = DatetimeIndex(ser).tz_convert("US/Eastern")
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = Timestamp("2020-12-31", tz="Europe/Berlin")
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
+
+
+def test_datetimeindex_tz_localize(using_copy_on_write):
+    dt = date_range("2019-12-31", periods=3, freq="D")
+    ser = Series(dt)
+    idx = DatetimeIndex(ser).tz_localize("Europe/Berlin")
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = Timestamp("2020-12-31")
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
+
+
+def test_datetimeindex_isocalendar(using_copy_on_write):
+    dt = date_range("2019-12-31", periods=3, freq="D")
+    ser = Series(dt)
+    df = DatetimeIndex(ser).isocalendar()
+    expected = df.index.copy(deep=True)
+    ser.iloc[0] = Timestamp("2020-12-31")
+    if using_copy_on_write:
+        tm.assert_index_equal(df.index, expected)
+
+
+def test_index_values(using_copy_on_write):
+    idx = date_range("2019-12-31", periods=3, freq="D")
+    result = idx.values
+    if using_copy_on_write:
+        assert result.flags.writeable is False
+    else:
+        assert result.flags.writeable is True
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..6411e20a972e79de82890105ed5cf37242d973f2
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_index.py
@@ -0,0 +1,178 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def index_view(index_data=[1, 2]):
+    df = DataFrame({"a": index_data, "b": 1.5})
+    view = df[:]
+    df = df.set_index("a", drop=True)
+    idx = df.index
+    # df = None
+    return idx, view
+
+
+def test_set_index_update_column(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1})
+    df = df.set_index("a", drop=False)
+    expected = df.index.copy(deep=True)
+    df.iloc[0, 0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(df.index, expected)
+    else:
+        tm.assert_index_equal(df.index, Index([100, 2], name="a"))
+
+
+def test_set_index_drop_update_column(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1.5})
+    view = df[:]
+    df = df.set_index("a", drop=True)
+    expected = df.index.copy(deep=True)
+    view.iloc[0, 0] = 100
+    tm.assert_index_equal(df.index, expected)
+
+
+def test_set_index_series(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1.5})
+    ser = Series([10, 11])
+    df = df.set_index(ser)
+    expected = df.index.copy(deep=True)
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(df.index, expected)
+    else:
+        tm.assert_index_equal(df.index, Index([100, 11]))
+
+
+def test_assign_index_as_series(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1.5})
+    ser = Series([10, 11])
+    df.index = ser
+    expected = df.index.copy(deep=True)
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(df.index, expected)
+    else:
+        tm.assert_index_equal(df.index, Index([100, 11]))
+
+
+def test_assign_index_as_index(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1.5})
+    ser = Series([10, 11])
+    rhs_index = Index(ser)
+    df.index = rhs_index
+    rhs_index = None  # overwrite to clear reference
+    expected = df.index.copy(deep=True)
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(df.index, expected)
+    else:
+        tm.assert_index_equal(df.index, Index([100, 11]))
+
+
+def test_index_from_series(using_copy_on_write):
+    ser = Series([1, 2])
+    idx = Index(ser)
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
+    else:
+        tm.assert_index_equal(idx, Index([100, 2]))
+
+
+def test_index_from_series_copy(using_copy_on_write):
+    ser = Series([1, 2])
+    idx = Index(ser, copy=True)  # noqa: F841
+    arr = get_array(ser)
+    ser.iloc[0] = 100
+    assert np.shares_memory(get_array(ser), arr)
+
+
+def test_index_from_index(using_copy_on_write):
+    ser = Series([1, 2])
+    idx = Index(ser)
+    idx = Index(idx)
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
+    else:
+        tm.assert_index_equal(idx, Index([100, 2]))
+
+
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda x: x._shallow_copy(x._values),
+        lambda x: x.view(),
+        lambda x: x.take([0, 1]),
+        lambda x: x.repeat([1, 1]),
+        lambda x: x[slice(0, 2)],
+        lambda x: x[[0, 1]],
+        lambda x: x._getitem_slice(slice(0, 2)),
+        lambda x: x.delete([]),
+        lambda x: x.rename("b"),
+        lambda x: x.astype("Int64", copy=False),
+    ],
+    ids=[
+        "_shallow_copy",
+        "view",
+        "take",
+        "repeat",
+        "getitem_slice",
+        "getitem_list",
+        "_getitem_slice",
+        "delete",
+        "rename",
+        "astype",
+    ],
+)
+def test_index_ops(using_copy_on_write, func, request):
+    idx, view_ = index_view()
+    expected = idx.copy(deep=True)
+    if "astype" in request.node.callspec.id:
+        expected = expected.astype("Int64")
+    idx = func(idx)
+    view_.iloc[0, 0] = 100
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected, check_names=False)
+
+
+def test_infer_objects(using_copy_on_write):
+    idx, view_ = index_view(["a", "b"])
+    expected = idx.copy(deep=True)
+    idx = idx.infer_objects(copy=False)
+    view_.iloc[0, 0] = "aaaa"
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected, check_names=False)
+
+
+def test_index_to_frame(using_copy_on_write):
+    idx = Index([1, 2, 3], name="a")
+    expected = idx.copy(deep=True)
+    df = idx.to_frame()
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "a"), idx._values)
+        assert not df._mgr._has_no_reference(0)
+    else:
+        assert not np.shares_memory(get_array(df, "a"), idx._values)
+
+    df.iloc[0, 0] = 100
+    tm.assert_index_equal(idx, expected)
+
+
+def test_index_values(using_copy_on_write):
+    idx = Index([1, 2, 3])
+    result = idx.values
+    if using_copy_on_write:
+        assert result.flags.writeable is False
+    else:
+        assert result.flags.writeable is True
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_periodindex.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_periodindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..94bc3a66f0e2b68049908db018a716a8fdc08fa5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_periodindex.py
@@ -0,0 +1,26 @@
+import pytest
+
+from pandas import (
+    Period,
+    PeriodIndex,
+    Series,
+    period_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "cons",
+    [
+        lambda x: PeriodIndex(x),
+        lambda x: PeriodIndex(PeriodIndex(x)),
+    ],
+)
+def test_periodindex(using_copy_on_write, cons):
+    dt = period_range("2019-12-31", periods=3, freq="D")
+    ser = Series(dt)
+    idx = cons(ser)
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = Period("2020-12-31")
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_timedeltaindex.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_timedeltaindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..a543e06cea3288f76caf3b2aea001fc65183ab50
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/copy_view/index/test_timedeltaindex.py
@@ -0,0 +1,26 @@
+import pytest
+
+from pandas import (
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "cons",
+    [
+        lambda x: TimedeltaIndex(x),
+        lambda x: TimedeltaIndex(TimedeltaIndex(x)),
+    ],
+)
+def test_timedeltaindex(using_copy_on_write, cons):
+    dt = timedelta_range("1 day", periods=3)
+    ser = Series(dt)
+    idx = cons(ser)
+    expected = idx.copy(deep=True)
+    ser.iloc[0] = Timedelta("5 days")
+    if using_copy_on_write:
+        tm.assert_index_equal(idx, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d77f1b23a538973586f85a9407c7bef2c62d884
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_common.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c7869aebc1cf5e26a9ed868d42c75221cd91dad
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_common.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_concat.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_concat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..24b337aea8e6f6cd8dd4100412d309493dd265c9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_concat.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_dtypes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_dtypes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..57fc28b0ecdef27e4069eb54fcd1f768f441d9be
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_dtypes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_generic.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_generic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9c3ccbf8aedf51f737b2f48b246b0e051f267b1
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_generic.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_inference.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_inference.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6803804806a01d9d2566134371134c8bbdaf792
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_inference.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61ce567da47465c15f0c6520f47cb58ca6438c2ec8eeb6798c923e4e5c03b199
+size 113420
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_missing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_missing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fcf764ae3e4732554218b51e8c525535a2e57de
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/__pycache__/test_missing.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..84b28a9eec609e57272ac8cdaca0a098a4cbfe22
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_can_hold_element.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_can_hold_element.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d44e6a9e00298beb6cdf949ae4bcb36089c9af5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_can_hold_element.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_from_scalar.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_from_scalar.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9bbf6779380074433a09e9abb9e0438d7c1d95f5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_from_scalar.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_ndarray.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_ndarray.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c99884f0dc5ea9f5ba2d370f26a676c19748f78
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_ndarray.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_object_arr.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_object_arr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c0d244edbf0d64b87b7adb5e61444968ee22c0e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_construct_object_arr.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_dict_compat.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_dict_compat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b64b65221058e225019e4eaba23118844a82b3f8
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_dict_compat.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_downcast.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_downcast.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e06c99a51c4894d1c7400bc434756e3104ac77f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_downcast.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_find_common_type.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_find_common_type.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06497903634600eb16b708045116badf6b34e323
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_find_common_type.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_infer_datetimelike.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_infer_datetimelike.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbca0f963dcc95940017408930fb872e88da4ab9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_infer_datetimelike.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_infer_dtype.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_infer_dtype.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7b04a3d91d9fc1e409e4cc5cf72a3f00d932058
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_infer_dtype.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_maybe_box_native.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_maybe_box_native.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2560032463e7308229b861bf663d2934a8299212
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_maybe_box_native.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_promote.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_promote.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9cf7a841832246c3901239135fcee4a213110bad
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/__pycache__/test_promote.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_can_hold_element.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_can_hold_element.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b7d76ead119a1bad784ca3fda3303c7a9e23244
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_can_hold_element.py
@@ -0,0 +1,79 @@
+import numpy as np
+
+from pandas.core.dtypes.cast import can_hold_element
+
+
+def test_can_hold_element_range(any_int_numpy_dtype):
+    # GH#44261
+    dtype = np.dtype(any_int_numpy_dtype)
+    arr = np.array([], dtype=dtype)
+
+    rng = range(2, 127)
+    assert can_hold_element(arr, rng)
+
+    # negatives -> can't be held by uint dtypes
+    rng = range(-2, 127)
+    if dtype.kind == "i":
+        assert can_hold_element(arr, rng)
+    else:
+        assert not can_hold_element(arr, rng)
+
+    rng = range(2, 255)
+    if dtype == "int8":
+        assert not can_hold_element(arr, rng)
+    else:
+        assert can_hold_element(arr, rng)
+
+    rng = range(-255, 65537)
+    if dtype.kind == "u":
+        assert not can_hold_element(arr, rng)
+    elif dtype.itemsize < 4:
+        assert not can_hold_element(arr, rng)
+    else:
+        assert can_hold_element(arr, rng)
+
+    # empty
+    rng = range(-(10**10), -(10**10))
+    assert len(rng) == 0
+    # assert can_hold_element(arr, rng)
+
+    rng = range(10**10, 10**10)
+    assert len(rng) == 0
+    assert can_hold_element(arr, rng)
+
+
+def test_can_hold_element_int_values_float_ndarray():
+    arr = np.array([], dtype=np.int64)
+
+    element = np.array([1.0, 2.0])
+    assert can_hold_element(arr, element)
+
+    assert not can_hold_element(arr, element + 0.5)
+
+    # integer but not losslessly castable to int64
+    element = np.array([3, 2**65], dtype=np.float64)
+    assert not can_hold_element(arr, element)
+
+
+def test_can_hold_element_int8_int():
+    arr = np.array([], dtype=np.int8)
+
+    element = 2
+    assert can_hold_element(arr, element)
+    assert can_hold_element(arr, np.int8(element))
+    assert can_hold_element(arr, np.uint8(element))
+    assert can_hold_element(arr, np.int16(element))
+    assert can_hold_element(arr, np.uint16(element))
+    assert can_hold_element(arr, np.int32(element))
+    assert can_hold_element(arr, np.uint32(element))
+    assert can_hold_element(arr, np.int64(element))
+    assert can_hold_element(arr, np.uint64(element))
+
+    element = 2**9
+    assert not can_hold_element(arr, element)
+    assert not can_hold_element(arr, np.int16(element))
+    assert not can_hold_element(arr, np.uint16(element))
+    assert not can_hold_element(arr, np.int32(element))
+    assert not can_hold_element(arr, np.uint32(element))
+    assert not can_hold_element(arr, np.int64(element))
+    assert not can_hold_element(arr, np.uint64(element))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_from_scalar.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_from_scalar.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ce04ce2e64cda1d3fc7c48390baa91ee2b06525
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_from_scalar.py
@@ -0,0 +1,55 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+from pandas import (
+    Categorical,
+    Timedelta,
+)
+import pandas._testing as tm
+
+
+def test_cast_1d_array_like_from_scalar_categorical():
+    # see gh-19565
+    #
+    # Categorical result from scalar did not maintain
+    # categories and ordering of the passed dtype.
+    cats = ["a", "b", "c"]
+    cat_type = CategoricalDtype(categories=cats, ordered=False)
+    expected = Categorical(["a", "a"], categories=cats)
+
+    result = construct_1d_arraylike_from_scalar("a", len(expected), cat_type)
+    tm.assert_categorical_equal(result, expected)
+
+
+def test_cast_1d_array_like_from_timestamp(fixed_now_ts):
+    # check we dont lose nanoseconds
+    ts = fixed_now_ts + Timedelta(1)
+    res = construct_1d_arraylike_from_scalar(ts, 2, np.dtype("M8[ns]"))
+    assert res[0] == ts
+
+
+def test_cast_1d_array_like_from_timedelta():
+    # check we dont lose nanoseconds
+    td = Timedelta(1)
+    res = construct_1d_arraylike_from_scalar(td, 2, np.dtype("m8[ns]"))
+    assert res[0] == td
+
+
+def test_cast_1d_array_like_mismatched_datetimelike():
+    td = np.timedelta64("NaT", "ns")
+    dt = np.datetime64("NaT", "ns")
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(td, 2, dt.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(np.timedelta64(4, "ns"), 2, dt.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(dt, 2, td.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(np.datetime64(4, "ns"), 2, td.dtype)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_ndarray.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_ndarray.py
new file mode 100644
index 0000000000000000000000000000000000000000..10085ddde5c8fc719cb4fdd0e212ceb0066c1192
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_ndarray.py
@@ -0,0 +1,30 @@
+import numpy as np
+import pytest
+
+import pandas._testing as tm
+from pandas.core.construction import sanitize_array
+
+
+@pytest.mark.parametrize(
+    "values, dtype, expected",
+    [
+        ([1, 2, 3], None, np.array([1, 2, 3], dtype=np.int64)),
+        (np.array([1, 2, 3]), None, np.array([1, 2, 3])),
+        (["1", "2", None], None, np.array(["1", "2", None])),
+        (["1", "2", None], np.dtype("str"), np.array(["1", "2", None])),
+        ([1, 2, None], np.dtype("str"), np.array(["1", "2", None])),
+    ],
+)
+def test_construct_1d_ndarray_preserving_na(values, dtype, expected):
+    result = sanitize_array(values, index=None, dtype=dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["m8[ns]", "M8[ns]"])
+def test_construct_1d_ndarray_preserving_na_datetimelike(dtype):
+    arr = np.arange(5, dtype=np.int64).view(dtype)
+    expected = np.array(list(arr), dtype=object)
+    assert all(isinstance(x, type(arr[0])) for x in expected)
+
+    result = sanitize_array(arr, index=None, dtype=np.dtype(object))
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_object_arr.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_object_arr.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb44f91f34dec80c090d3ce3fc9a2dbd4578bb57
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_construct_object_arr.py
@@ -0,0 +1,20 @@
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+
+
+@pytest.mark.parametrize("datum1", [1, 2.0, "3", (4, 5), [6, 7], None])
+@pytest.mark.parametrize("datum2", [8, 9.0, "10", (11, 12), [13, 14], None])
+def test_cast_1d_array(datum1, datum2):
+    data = [datum1, datum2]
+    result = construct_1d_object_array_from_listlike(data)
+
+    # Direct comparison fails: https://github.com/numpy/numpy/issues/10218
+    assert result.dtype == "object"
+    assert list(result) == data
+
+
+@pytest.mark.parametrize("val", [1, 2.0, None])
+def test_cast_1d_array_invalid_scalar(val):
+    with pytest.raises(TypeError, match="has no len()"):
+        construct_1d_object_array_from_listlike(val)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_dict_compat.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_dict_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..13dc82d779f953fbea54323785bdcadc3e24dfd8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_dict_compat.py
@@ -0,0 +1,14 @@
+import numpy as np
+
+from pandas.core.dtypes.cast import dict_compat
+
+from pandas import Timestamp
+
+
+def test_dict_compat():
+    data_datetime64 = {np.datetime64("1990-03-15"): 1, np.datetime64("2015-03-15"): 2}
+    data_unchanged = {1: 2, 3: 4, 5: 6}
+    expected = {Timestamp("1990-3-15"): 1, Timestamp("2015-03-15"): 2}
+    assert dict_compat(data_datetime64) == expected
+    assert dict_compat(expected) == expected
+    assert dict_compat(data_unchanged) == data_unchanged
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_downcast.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_downcast.py
new file mode 100644
index 0000000000000000000000000000000000000000..c01eac746455c5832901e90becf026c29a5ede10
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_downcast.py
@@ -0,0 +1,97 @@
+import decimal
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_downcast_to_dtype
+
+from pandas import (
+    Series,
+    Timedelta,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "arr,dtype,expected",
+    [
+        (
+            np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),
+            "infer",
+            np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),
+        ),
+        (
+            np.array([8.0, 8.0, 8.0, 8.0, 8.9999999999995]),
+            "infer",
+            np.array([8, 8, 8, 8, 9], dtype=np.int64),
+        ),
+        (
+            np.array([8.0, 8.0, 8.0, 8.0, 9.0000000000005]),
+            "infer",
+            np.array([8, 8, 8, 8, 9], dtype=np.int64),
+        ),
+        (
+            # This is a judgement call, but we do _not_ downcast Decimal
+            #  objects
+            np.array([decimal.Decimal(0.0)]),
+            "int64",
+            np.array([decimal.Decimal(0.0)]),
+        ),
+        (
+            # GH#45837
+            np.array([Timedelta(days=1), Timedelta(days=2)], dtype=object),
+            "infer",
+            np.array([1, 2], dtype="m8[D]").astype("m8[ns]"),
+        ),
+        # TODO: similar for dt64, dt64tz, Period, Interval?
+    ],
+)
+def test_downcast(arr, expected, dtype):
+    result = maybe_downcast_to_dtype(arr, dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_downcast_booleans():
+    # see gh-16875: coercing of booleans.
+    ser = Series([True, True, False])
+    result = maybe_downcast_to_dtype(ser, np.dtype(np.float64))
+
+    expected = ser
+    tm.assert_series_equal(result, expected)
+
+
+def test_downcast_conversion_no_nan(any_real_numpy_dtype):
+    dtype = any_real_numpy_dtype
+    expected = np.array([1, 2])
+    arr = np.array([1.0, 2.0], dtype=dtype)
+
+    result = maybe_downcast_to_dtype(arr, "infer")
+    tm.assert_almost_equal(result, expected, check_dtype=False)
+
+
+def test_downcast_conversion_nan(float_numpy_dtype):
+    dtype = float_numpy_dtype
+    data = [1.0, 2.0, np.nan]
+
+    expected = np.array(data, dtype=dtype)
+    arr = np.array(data, dtype=dtype)
+
+    result = maybe_downcast_to_dtype(arr, "infer")
+    tm.assert_almost_equal(result, expected)
+
+
+def test_downcast_conversion_empty(any_real_numpy_dtype):
+    dtype = any_real_numpy_dtype
+    arr = np.array([], dtype=dtype)
+    result = maybe_downcast_to_dtype(arr, np.dtype("int64"))
+    tm.assert_numpy_array_equal(result, np.array([], dtype=np.int64))
+
+
+@pytest.mark.parametrize("klass", [np.datetime64, np.timedelta64])
+def test_datetime_likes_nan(klass):
+    dtype = klass.__name__ + "[ns]"
+    arr = np.array([1, 2, np.nan])
+
+    exp = np.array([1, 2, klass("NaT")], dtype)
+    res = maybe_downcast_to_dtype(arr, dtype)
+    tm.assert_numpy_array_equal(res, exp)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_find_common_type.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_find_common_type.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ce05337be70b91e4ad887da8d38a4e0e4e59543
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_find_common_type.py
@@ -0,0 +1,175 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+
+from pandas import (
+    Categorical,
+    Index,
+)
+
+
+@pytest.mark.parametrize(
+    "source_dtypes,expected_common_dtype",
+    [
+        ((np.int64,), np.int64),
+        ((np.uint64,), np.uint64),
+        ((np.float32,), np.float32),
+        ((object,), object),
+        # Into ints.
+        ((np.int16, np.int64), np.int64),
+        ((np.int32, np.uint32), np.int64),
+        ((np.uint16, np.uint64), np.uint64),
+        # Into floats.
+        ((np.float16, np.float32), np.float32),
+        ((np.float16, np.int16), np.float32),
+        ((np.float32, np.int16), np.float32),
+        ((np.uint64, np.int64), np.float64),
+        ((np.int16, np.float64), np.float64),
+        ((np.float16, np.int64), np.float64),
+        # Into others.
+        ((np.complex128, np.int32), np.complex128),
+        ((object, np.float32), object),
+        ((object, np.int16), object),
+        # Bool with int.
+        ((np.dtype("bool"), np.int64), object),
+        ((np.dtype("bool"), np.int32), object),
+        ((np.dtype("bool"), np.int16), object),
+        ((np.dtype("bool"), np.int8), object),
+        ((np.dtype("bool"), np.uint64), object),
+        ((np.dtype("bool"), np.uint32), object),
+        ((np.dtype("bool"), np.uint16), object),
+        ((np.dtype("bool"), np.uint8), object),
+        # Bool with float.
+        ((np.dtype("bool"), np.float64), object),
+        ((np.dtype("bool"), np.float32), object),
+        (
+            (np.dtype("datetime64[ns]"), np.dtype("datetime64[ns]")),
+            np.dtype("datetime64[ns]"),
+        ),
+        (
+            (np.dtype("timedelta64[ns]"), np.dtype("timedelta64[ns]")),
+            np.dtype("timedelta64[ns]"),
+        ),
+        (
+            (np.dtype("datetime64[ns]"), np.dtype("datetime64[ms]")),
+            np.dtype("datetime64[ns]"),
+        ),
+        (
+            (np.dtype("timedelta64[ms]"), np.dtype("timedelta64[ns]")),
+            np.dtype("timedelta64[ns]"),
+        ),
+        ((np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")), object),
+        ((np.dtype("datetime64[ns]"), np.int64), object),
+    ],
+)
+def test_numpy_dtypes(source_dtypes, expected_common_dtype):
+    source_dtypes = [pandas_dtype(x) for x in source_dtypes]
+    assert find_common_type(source_dtypes) == expected_common_dtype
+
+
+def test_raises_empty_input():
+    with pytest.raises(ValueError, match="no types given"):
+        find_common_type([])
+
+
+@pytest.mark.parametrize(
+    "dtypes,exp_type",
+    [
+        ([CategoricalDtype()], "category"),
+        ([object, CategoricalDtype()], object),
+        ([CategoricalDtype(), CategoricalDtype()], "category"),
+    ],
+)
+def test_categorical_dtype(dtypes, exp_type):
+    assert find_common_type(dtypes) == exp_type
+
+
+def test_datetimetz_dtype_match():
+    dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+    assert find_common_type([dtype, dtype]) == "datetime64[ns, US/Eastern]"
+
+
+@pytest.mark.parametrize(
+    "dtype2",
+    [
+        DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+        np.dtype("datetime64[ns]"),
+        object,
+        np.int64,
+    ],
+)
+def test_datetimetz_dtype_mismatch(dtype2):
+    dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+    assert find_common_type([dtype, dtype2]) == object
+    assert find_common_type([dtype2, dtype]) == object
+
+
+def test_period_dtype_match():
+    dtype = PeriodDtype(freq="D")
+    assert find_common_type([dtype, dtype]) == "period[D]"
+
+
+@pytest.mark.parametrize(
+    "dtype2",
+    [
+        DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+        PeriodDtype(freq="2D"),
+        PeriodDtype(freq="H"),
+        np.dtype("datetime64[ns]"),
+        object,
+        np.int64,
+    ],
+)
+def test_period_dtype_mismatch(dtype2):
+    dtype = PeriodDtype(freq="D")
+    assert find_common_type([dtype, dtype2]) == object
+    assert find_common_type([dtype2, dtype]) == object
+
+
+interval_dtypes = [
+    IntervalDtype(np.int64, "right"),
+    IntervalDtype(np.float64, "right"),
+    IntervalDtype(np.uint64, "right"),
+    IntervalDtype(DatetimeTZDtype(unit="ns", tz="US/Eastern"), "right"),
+    IntervalDtype("M8[ns]", "right"),
+    IntervalDtype("m8[ns]", "right"),
+]
+
+
+@pytest.mark.parametrize("left", interval_dtypes)
+@pytest.mark.parametrize("right", interval_dtypes)
+def test_interval_dtype(left, right):
+    result = find_common_type([left, right])
+
+    if left is right:
+        assert result is left
+
+    elif left.subtype.kind in ["i", "u", "f"]:
+        # i.e. numeric
+        if right.subtype.kind in ["i", "u", "f"]:
+            # both numeric -> common numeric subtype
+            expected = IntervalDtype(np.float64, "right")
+            assert result == expected
+        else:
+            assert result == object
+
+    else:
+        assert result == object
+
+
+@pytest.mark.parametrize("dtype", interval_dtypes)
+def test_interval_dtype_with_categorical(dtype):
+    obj = Index([], dtype=dtype)
+
+    cat = Categorical([], categories=obj)
+
+    result = find_common_type([dtype, cat.dtype])
+    assert result == dtype
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_infer_datetimelike.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_infer_datetimelike.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c3844e69586d2f49377e77910627ee42fef9bb2
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_infer_datetimelike.py
@@ -0,0 +1,28 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    NaT,
+    Series,
+    Timestamp,
+)
+
+
+@pytest.mark.parametrize(
+    "data,exp_size",
+    [
+        # see gh-16362.
+        ([[NaT, "a", "b", 0], [NaT, "b", "c", 1]], 8),
+        ([[NaT, "a", 0], [NaT, "b", 1]], 6),
+    ],
+)
+def test_maybe_infer_to_datetimelike_df_construct(data, exp_size):
+    result = DataFrame(np.array(data))
+    assert result.size == exp_size
+
+
+def test_maybe_infer_to_datetimelike_ser_construct():
+    # see gh-19671.
+    result = Series(["M1701", Timestamp("20130101")])
+    assert result.dtype.kind == "O"
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_infer_dtype.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_infer_dtype.py
new file mode 100644
index 0000000000000000000000000000000000000000..50eaa1f4d871373037ee5304aaccc95e1b7a73ab
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_infer_dtype.py
@@ -0,0 +1,208 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import (
+    infer_dtype_from,
+    infer_dtype_from_array,
+    infer_dtype_from_scalar,
+)
+from pandas.core.dtypes.common import is_dtype_equal
+
+from pandas import (
+    Categorical,
+    Interval,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+
+
+def test_infer_dtype_from_int_scalar(any_int_numpy_dtype):
+    # Test that infer_dtype_from_scalar is
+    # returning correct dtype for int and float.
+    data = np.dtype(any_int_numpy_dtype).type(12)
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == type(data)
+
+
+def test_infer_dtype_from_float_scalar(float_numpy_dtype):
+    float_numpy_dtype = np.dtype(float_numpy_dtype).type
+    data = float_numpy_dtype(12)
+
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == float_numpy_dtype
+
+
+@pytest.mark.parametrize(
+    "data,exp_dtype", [(12, np.int64), (np.float64(12), np.float64)]
+)
+def test_infer_dtype_from_python_scalar(data, exp_dtype):
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == exp_dtype
+
+
+@pytest.mark.parametrize("bool_val", [True, False])
+def test_infer_dtype_from_boolean(bool_val):
+    dtype, val = infer_dtype_from_scalar(bool_val)
+    assert dtype == np.bool_
+
+
+def test_infer_dtype_from_complex(complex_dtype):
+    data = np.dtype(complex_dtype).type(1)
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == np.complex128
+
+
+def test_infer_dtype_from_datetime():
+    dt64 = np.datetime64(1, "ns")
+    dtype, val = infer_dtype_from_scalar(dt64)
+    assert dtype == "M8[ns]"
+
+    ts = Timestamp(1)
+    dtype, val = infer_dtype_from_scalar(ts)
+    assert dtype == "M8[ns]"
+
+    dt = datetime(2000, 1, 1, 0, 0)
+    dtype, val = infer_dtype_from_scalar(dt)
+    assert dtype == "M8[us]"
+
+
+def test_infer_dtype_from_timedelta():
+    td64 = np.timedelta64(1, "ns")
+    dtype, val = infer_dtype_from_scalar(td64)
+    assert dtype == "m8[ns]"
+
+    pytd = timedelta(1)
+    dtype, val = infer_dtype_from_scalar(pytd)
+    assert dtype == "m8[us]"
+
+    td = Timedelta(1)
+    dtype, val = infer_dtype_from_scalar(td)
+    assert dtype == "m8[ns]"
+
+
+@pytest.mark.parametrize("freq", ["M", "D"])
+def test_infer_dtype_from_period(freq):
+    p = Period("2011-01-01", freq=freq)
+    dtype, val = infer_dtype_from_scalar(p)
+
+    exp_dtype = f"period[{freq}]"
+
+    assert dtype == exp_dtype
+    assert val == p
+
+
+def test_infer_dtype_misc():
+    dt = date(2000, 1, 1)
+    dtype, val = infer_dtype_from_scalar(dt)
+    assert dtype == np.object_
+
+    ts = Timestamp(1, tz="US/Eastern")
+    dtype, val = infer_dtype_from_scalar(ts)
+    assert dtype == "datetime64[ns, US/Eastern]"
+
+
+@pytest.mark.parametrize("tz", ["UTC", "US/Eastern", "Asia/Tokyo"])
+def test_infer_from_scalar_tz(tz):
+    dt = Timestamp(1, tz=tz)
+    dtype, val = infer_dtype_from_scalar(dt)
+
+    exp_dtype = f"datetime64[ns, {tz}]"
+
+    assert dtype == exp_dtype
+    assert val == dt
+
+
+@pytest.mark.parametrize(
+    "left, right, subtype",
+    [
+        (0, 1, "int64"),
+        (0.0, 1.0, "float64"),
+        (Timestamp(0), Timestamp(1), "datetime64[ns]"),
+        (Timestamp(0, tz="UTC"), Timestamp(1, tz="UTC"), "datetime64[ns, UTC]"),
+        (Timedelta(0), Timedelta(1), "timedelta64[ns]"),
+    ],
+)
+def test_infer_from_interval(left, right, subtype, closed):
+    # GH 30337
+    interval = Interval(left, right, closed)
+    result_dtype, result_value = infer_dtype_from_scalar(interval)
+    expected_dtype = f"interval[{subtype}, {closed}]"
+    assert result_dtype == expected_dtype
+    assert result_value == interval
+
+
+def test_infer_dtype_from_scalar_errors():
+    msg = "invalid ndarray passed to infer_dtype_from_scalar"
+
+    with pytest.raises(ValueError, match=msg):
+        infer_dtype_from_scalar(np.array([1]))
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        ("foo", np.object_),
+        (b"foo", np.object_),
+        (1, np.int64),
+        (1.5, np.float64),
+        (np.datetime64("2016-01-01"), np.dtype("M8[s]")),
+        (Timestamp("20160101"), np.dtype("M8[s]")),
+        (Timestamp("20160101", tz="UTC"), "datetime64[s, UTC]"),
+    ],
+)
+def test_infer_dtype_from_scalar(value, expected):
+    dtype, _ = infer_dtype_from_scalar(value)
+    assert is_dtype_equal(dtype, expected)
+
+    with pytest.raises(TypeError, match="must be list-like"):
+        infer_dtype_from_array(value)
+
+
+@pytest.mark.parametrize(
+    "arr, expected",
+    [
+        ([1], np.dtype(int)),
+        (np.array([1], dtype=np.int64), np.int64),
+        ([np.nan, 1, ""], np.object_),
+        (np.array([[1.0, 2.0]]), np.float64),
+        (Categorical(list("aabc")), "category"),
+        (Categorical([1, 2, 3]), "category"),
+        (date_range("20160101", periods=3), np.dtype("=M8[ns]")),
+        (
+            date_range("20160101", periods=3, tz="US/Eastern"),
+            "datetime64[ns, US/Eastern]",
+        ),
+        (Series([1.0, 2, 3]), np.float64),
+        (Series(list("abc")), np.object_),
+        (
+            Series(date_range("20160101", periods=3, tz="US/Eastern")),
+            "datetime64[ns, US/Eastern]",
+        ),
+    ],
+)
+def test_infer_dtype_from_array(arr, expected):
+    dtype, _ = infer_dtype_from_array(arr)
+    assert is_dtype_equal(dtype, expected)
+
+
+@pytest.mark.parametrize("cls", [np.datetime64, np.timedelta64])
+def test_infer_dtype_from_scalar_zerodim_datetimelike(cls):
+    # ndarray.item() can incorrectly return int instead of td64/dt64
+    val = cls(1234, "ns")
+    arr = np.array(val)
+
+    dtype, res = infer_dtype_from_scalar(arr)
+    assert dtype.type is cls
+    assert isinstance(res, cls)
+
+    dtype, res = infer_dtype_from(arr)
+    assert dtype.type is cls
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_maybe_box_native.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_maybe_box_native.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f62f31dac2191a15d7df8db028a9286262d0080
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_maybe_box_native.py
@@ -0,0 +1,40 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_box_native
+
+from pandas import (
+    Interval,
+    Period,
+    Timedelta,
+    Timestamp,
+)
+
+
+@pytest.mark.parametrize(
+    "obj,expected_dtype",
+    [
+        (b"\x00\x10", bytes),
+        (int(4), int),
+        (np.uint(4), int),
+        (np.int32(-4), int),
+        (np.uint8(4), int),
+        (float(454.98), float),
+        (np.float16(0.4), float),
+        (np.float64(1.4), float),
+        (np.bool_(False), bool),
+        (datetime(2005, 2, 25), datetime),
+        (np.datetime64("2005-02-25"), Timestamp),
+        (Timestamp("2005-02-25"), Timestamp),
+        (np.timedelta64(1, "D"), Timedelta),
+        (Timedelta(1, "D"), Timedelta),
+        (Interval(0, 1), Interval),
+        (Period("4Q2005"), Period),
+    ],
+)
+def test_maybe_box_native(obj, expected_dtype):
+    boxed_obj = maybe_box_native(obj)
+    result_dtype = type(boxed_obj)
+    assert result_dtype is expected_dtype
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_promote.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_promote.py
new file mode 100644
index 0000000000000000000000000000000000000000..1becf3b9843b7effbbd97b6ca80e21005cda73e1
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/dtypes/cast/test_promote.py
@@ -0,0 +1,530 @@
+"""
+These test the method maybe_promote from core/dtypes/cast.py
+"""
+
+import datetime
+from decimal import Decimal
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import NaT
+
+from pandas.core.dtypes.cast import maybe_promote
+from pandas.core.dtypes.common import is_scalar
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.missing import isna
+
+import pandas as pd
+
+
+def _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar=None):
+    """
+    Auxiliary function to unify testing of scalar/array promotion.
+
+    Parameters
+    ----------
+    dtype : dtype
+        The value to pass on as the first argument to maybe_promote.
+    fill_value : scalar
+        The value to pass on as the second argument to maybe_promote as
+        a scalar.
+    expected_dtype : dtype
+        The expected dtype returned by maybe_promote (by design this is the
+        same regardless of whether fill_value was passed as a scalar or in an
+        array!).
+    exp_val_for_scalar : scalar
+        The expected value for the (potentially upcast) fill_value returned by
+        maybe_promote.
+    """
+    assert is_scalar(fill_value)
+
+    # here, we pass on fill_value as a scalar directly; the expected value
+    # returned from maybe_promote is fill_value, potentially upcast to the
+    # returned dtype.
+    result_dtype, result_fill_value = maybe_promote(dtype, fill_value)
+    expected_fill_value = exp_val_for_scalar
+
+    assert result_dtype == expected_dtype
+    _assert_match(result_fill_value, expected_fill_value)
+
+
+def _assert_match(result_fill_value, expected_fill_value):
+    # GH#23982/25425 require the same type in addition to equality/NA-ness
+    res_type = type(result_fill_value)
+    ex_type = type(expected_fill_value)
+
+    if hasattr(result_fill_value, "dtype"):
+        # Compare types in a way that is robust to platform-specific
+        #  idiosyncrasies where e.g. sometimes we get "ulonglong" as an alias
+        #  for "uint64" or "intc" as an alias for "int32"
+        assert result_fill_value.dtype.kind == expected_fill_value.dtype.kind
+        assert result_fill_value.dtype.itemsize == expected_fill_value.dtype.itemsize
+    else:
+        # On some builds, type comparison fails, e.g. np.int32 != np.int32
+        assert res_type == ex_type or res_type.__name__ == ex_type.__name__
+
+    match_value = result_fill_value == expected_fill_value
+    if match_value is pd.NA:
+        match_value = False
+
+    # Note: type check above ensures that we have the _same_ NA value
+    # for missing values, None == None (which is checked
+    # through match_value above), but np.nan != np.nan and pd.NaT != pd.NaT
+    match_missing = isna(result_fill_value) and isna(expected_fill_value)
+
+    assert match_value or match_missing
+
+
+@pytest.mark.parametrize(
+    "dtype, fill_value, expected_dtype",
+    [
+        # size 8
+        ("int8", 1, "int8"),
+        ("int8", np.iinfo("int8").max + 1, "int16"),
+        ("int8", np.iinfo("int16").max + 1, "int32"),
+        ("int8", np.iinfo("int32").max + 1, "int64"),
+        ("int8", np.iinfo("int64").max + 1, "object"),
+        ("int8", -1, "int8"),
+        ("int8", np.iinfo("int8").min - 1, "int16"),
+        ("int8", np.iinfo("int16").min - 1, "int32"),
+        ("int8", np.iinfo("int32").min - 1, "int64"),
+        ("int8", np.iinfo("int64").min - 1, "object"),
+        # keep signed-ness as long as possible
+        ("uint8", 1, "uint8"),
+        ("uint8", np.iinfo("int8").max + 1, "uint8"),
+        ("uint8", np.iinfo("uint8").max + 1, "uint16"),
+        ("uint8", np.iinfo("int16").max + 1, "uint16"),
+        ("uint8", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint8", np.iinfo("int32").max + 1, "uint32"),
+        ("uint8", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint8", np.iinfo("int64").max + 1, "uint64"),
+        ("uint8", np.iinfo("uint64").max + 1, "object"),
+        # max of uint8 cannot be contained in int8
+        ("uint8", -1, "int16"),
+        ("uint8", np.iinfo("int8").min - 1, "int16"),
+        ("uint8", np.iinfo("int16").min - 1, "int32"),
+        ("uint8", np.iinfo("int32").min - 1, "int64"),
+        ("uint8", np.iinfo("int64").min - 1, "object"),
+        # size 16
+        ("int16", 1, "int16"),
+        ("int16", np.iinfo("int8").max + 1, "int16"),
+        ("int16", np.iinfo("int16").max + 1, "int32"),
+        ("int16", np.iinfo("int32").max + 1, "int64"),
+        ("int16", np.iinfo("int64").max + 1, "object"),
+        ("int16", -1, "int16"),
+        ("int16", np.iinfo("int8").min - 1, "int16"),
+        ("int16", np.iinfo("int16").min - 1, "int32"),
+        ("int16", np.iinfo("int32").min - 1, "int64"),
+        ("int16", np.iinfo("int64").min - 1, "object"),
+        ("uint16", 1, "uint16"),
+        ("uint16", np.iinfo("int8").max + 1, "uint16"),
+        ("uint16", np.iinfo("uint8").max + 1, "uint16"),
+        ("uint16", np.iinfo("int16").max + 1, "uint16"),
+        ("uint16", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint16", np.iinfo("int32").max + 1, "uint32"),
+        ("uint16", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint16", np.iinfo("int64").max + 1, "uint64"),
+        ("uint16", np.iinfo("uint64").max + 1, "object"),
+        ("uint16", -1, "int32"),
+        ("uint16", np.iinfo("int8").min - 1, "int32"),
+        ("uint16", np.iinfo("int16").min - 1, "int32"),
+        ("uint16", np.iinfo("int32").min - 1, "int64"),
+        ("uint16", np.iinfo("int64").min - 1, "object"),
+        # size 32
+        ("int32", 1, "int32"),
+        ("int32", np.iinfo("int8").max + 1, "int32"),
+        ("int32", np.iinfo("int16").max + 1, "int32"),
+        ("int32", np.iinfo("int32").max + 1, "int64"),
+        ("int32", np.iinfo("int64").max + 1, "object"),
+        ("int32", -1, "int32"),
+        ("int32", np.iinfo("int8").min - 1, "int32"),
+        ("int32", np.iinfo("int16").min - 1, "int32"),
+        ("int32", np.iinfo("int32").min - 1, "int64"),
+        ("int32", np.iinfo("int64").min - 1, "object"),
+        ("uint32", 1, "uint32"),
+        ("uint32", np.iinfo("int8").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint8").max + 1, "uint32"),
+        ("uint32", np.iinfo("int16").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint32", np.iinfo("int32").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint32", np.iinfo("int64").max + 1, "uint64"),
+        ("uint32", np.iinfo("uint64").max + 1, "object"),
+        ("uint32", -1, "int64"),
+        ("uint32", np.iinfo("int8").min - 1, "int64"),
+        ("uint32", np.iinfo("int16").min - 1, "int64"),
+        ("uint32", np.iinfo("int32").min - 1, "int64"),
+        ("uint32", np.iinfo("int64").min - 1, "object"),
+        # size 64
+        ("int64", 1, "int64"),
+        ("int64", np.iinfo("int8").max + 1, "int64"),
+        ("int64", np.iinfo("int16").max + 1, "int64"),
+        ("int64", np.iinfo("int32").max + 1, "int64"),
+        ("int64", np.iinfo("int64").max + 1, "object"),
+        ("int64", -1, "int64"),
+        ("int64", np.iinfo("int8").min - 1, "int64"),
+        ("int64", np.iinfo("int16").min - 1, "int64"),
+        ("int64", np.iinfo("int32").min - 1, "int64"),
+        ("int64", np.iinfo("int64").min - 1, "object"),
+        ("uint64", 1, "uint64"),
+        ("uint64", np.iinfo("int8").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint8").max + 1, "uint64"),
+        ("uint64", np.iinfo("int16").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint16").max + 1, "uint64"),
+        ("uint64", np.iinfo("int32").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint64", np.iinfo("int64").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint64").max + 1, "object"),
+        ("uint64", -1, "object"),
+        ("uint64", np.iinfo("int8").min - 1, "object"),
+        ("uint64", np.iinfo("int16").min - 1, "object"),
+        ("uint64", np.iinfo("int32").min - 1, "object"),
+        ("uint64", np.iinfo("int64").min - 1, "object"),
+    ],
+)
+def test_maybe_promote_int_with_int(dtype, fill_value, expected_dtype):
+    dtype = np.dtype(dtype)
+    expected_dtype = np.dtype(expected_dtype)
+
+    # output is not a generic int, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_int_with_float(any_int_numpy_dtype, float_numpy_dtype):
+    dtype = np.dtype(any_int_numpy_dtype)
+    fill_dtype = np.dtype(float_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling int with float always upcasts to float64
+    expected_dtype = np.float64
+    # fill_value can be different float type
+    exp_val_for_scalar = np.float64(fill_value)
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_float_with_int(float_numpy_dtype, any_int_numpy_dtype):
+    dtype = np.dtype(float_numpy_dtype)
+    fill_dtype = np.dtype(any_int_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling float with int always keeps float dtype
+    # because: np.finfo('float32').max > np.iinfo('uint64').max
+    expected_dtype = dtype
+    # output is not a generic float, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "dtype, fill_value, expected_dtype",
+    [
+        # float filled with float
+        ("float32", 1, "float32"),
+        ("float32", np.finfo("float32").max * 1.1, "float64"),
+        ("float64", 1, "float64"),
+        ("float64", np.finfo("float32").max * 1.1, "float64"),
+        # complex filled with float
+        ("complex64", 1, "complex64"),
+        ("complex64", np.finfo("float32").max * 1.1, "complex128"),
+        ("complex128", 1, "complex128"),
+        ("complex128", np.finfo("float32").max * 1.1, "complex128"),
+        # float filled with complex
+        ("float32", 1 + 1j, "complex64"),
+        ("float32", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+        ("float64", 1 + 1j, "complex128"),
+        ("float64", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+        # complex filled with complex
+        ("complex64", 1 + 1j, "complex64"),
+        ("complex64", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+        ("complex128", 1 + 1j, "complex128"),
+        ("complex128", np.finfo("float32").max * (1.1 + 1j), "complex128"),
+    ],
+)
+def test_maybe_promote_float_with_float(dtype, fill_value, expected_dtype):
+    dtype = np.dtype(dtype)
+    expected_dtype = np.dtype(expected_dtype)
+
+    # output is not a generic float, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_bool_with_any(any_numpy_dtype):
+    dtype = np.dtype(bool)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling bool with anything but bool casts to object
+    expected_dtype = np.dtype(object) if fill_dtype != bool else fill_dtype
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_bool(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+    fill_value = True
+
+    # filling anything but bool with bool casts to object
+    expected_dtype = np.dtype(object) if dtype != bool else dtype
+    # output is not a generic bool, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_bytes_with_any(bytes_dtype, any_numpy_dtype):
+    dtype = np.dtype(bytes_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # we never use bytes dtype internally, always promote to object
+    expected_dtype = np.dtype(np.object_)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_bytes(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype
+    fill_value = b"abc"
+
+    # we never use bytes dtype internally, always promote to object
+    expected_dtype = np.dtype(np.object_)
+    # output is not a generic bytes, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_datetime64_with_any(datetime64_dtype, any_numpy_dtype):
+    dtype = np.dtype(datetime64_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling datetime with anything but datetime casts to object
+    if fill_dtype.kind == "M":
+        expected_dtype = dtype
+        # for datetime dtypes, scalar values get cast to to_datetime64
+        exp_val_for_scalar = pd.Timestamp(fill_value).to_datetime64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "fill_value",
+    [
+        pd.Timestamp("now"),
+        np.datetime64("now"),
+        datetime.datetime.now(),
+        datetime.date.today(),
+    ],
+    ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
+)
+def test_maybe_promote_any_with_datetime64(any_numpy_dtype, fill_value):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # filling datetime with anything but datetime casts to object
+    if dtype.kind == "M":
+        expected_dtype = dtype
+        # for datetime dtypes, scalar values get cast to pd.Timestamp.value
+        exp_val_for_scalar = pd.Timestamp(fill_value).to_datetime64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    if type(fill_value) is datetime.date and dtype.kind == "M":
+        # Casting date to dt64 is deprecated, in 2.0 enforced to cast to object
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "fill_value",
+    [
+        pd.Timestamp(2023, 1, 1),
+        np.datetime64("2023-01-01"),
+        datetime.datetime(2023, 1, 1),
+        datetime.date(2023, 1, 1),
+    ],
+    ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
+)
+def test_maybe_promote_any_numpy_dtype_with_datetimetz(
+    any_numpy_dtype, tz_aware_fixture, fill_value
+):
+    dtype = np.dtype(any_numpy_dtype)
+    fill_dtype = DatetimeTZDtype(tz=tz_aware_fixture)
+
+    fill_value = pd.Series([fill_value], dtype=fill_dtype)[0]
+
+    # filling any numpy dtype with datetimetz casts to object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_timedelta64_with_any(timedelta64_dtype, any_numpy_dtype):
+    dtype = np.dtype(timedelta64_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling timedelta with anything but timedelta casts to object
+    if fill_dtype.kind == "m":
+        expected_dtype = dtype
+        # for timedelta dtypes, scalar values get cast to pd.Timedelta.value
+        exp_val_for_scalar = pd.Timedelta(fill_value).to_timedelta64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "fill_value",
+    [pd.Timedelta(days=1), np.timedelta64(24, "h"), datetime.timedelta(1)],
+    ids=["pd.Timedelta", "np.timedelta64", "datetime.timedelta"],
+)
+def test_maybe_promote_any_with_timedelta64(any_numpy_dtype, fill_value):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # filling anything but timedelta with timedelta casts to object
+    if dtype.kind == "m":
+        expected_dtype = dtype
+        # for timedelta dtypes, scalar values get cast to pd.Timedelta.value
+        exp_val_for_scalar = pd.Timedelta(fill_value).to_timedelta64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_string_with_any(string_dtype, any_numpy_dtype):
+    dtype = np.dtype(string_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling string with anything casts to object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_string(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype
+    fill_value = "abc"
+
+    # filling anything with a string casts to object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_object_with_any(object_dtype, any_numpy_dtype):
+    dtype = np.dtype(object_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling object with anything stays object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_object(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # create array of object dtype from a scalar value (i.e. passing
+    # dtypes.common.is_scalar), which can however not be cast to int/float etc.
+    fill_value = pd.DateOffset(1)
+
+    # filling object with anything stays object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_numpy_dtype_with_na(any_numpy_dtype, nulls_fixture):
+    fill_value = nulls_fixture
+    dtype = np.dtype(any_numpy_dtype)
+
+    if isinstance(fill_value, Decimal):
+        # Subject to change, but ATM (When Decimal(NAN) is being added to nulls_fixture)
+        #  this is the existing behavior in maybe_promote,
+        #  hinges on is_valid_na_for_dtype
+        if dtype.kind in "iufc":
+            if dtype.kind in "iu":
+                expected_dtype = np.dtype(np.float64)
+            else:
+                expected_dtype = dtype
+            exp_val_for_scalar = np.nan
+        else:
+            expected_dtype = np.dtype(object)
+            exp_val_for_scalar = fill_value
+    elif dtype.kind in "iu" and fill_value is not NaT:
+        # integer + other missing value (np.nan / None) casts to float
+        expected_dtype = np.float64
+        exp_val_for_scalar = np.nan
+    elif dtype == object and fill_value is NaT:
+        # inserting into object does not cast the value
+        # but *does* cast None to np.nan
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+    elif dtype.kind in "mM":
+        # datetime / timedelta cast all missing values to dtyped-NaT
+        expected_dtype = dtype
+        exp_val_for_scalar = dtype.type("NaT", "ns")
+    elif fill_value is NaT:
+        # NaT upcasts everything that's not datetime/timedelta to object
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = NaT
+    elif dtype.kind in "fc":
+        # float / complex + missing value (!= NaT) stays the same
+        expected_dtype = dtype
+        exp_val_for_scalar = np.nan
+    else:
+        # all other cases cast to object, and use np.nan as missing value
+        expected_dtype = np.dtype(object)
+        if fill_value is pd.NA:
+            exp_val_for_scalar = pd.NA
+        else:
+            exp_val_for_scalar = np.nan
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..448756d289ab88bfd74943513b75973ab1386b40
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/common.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..75cc6226e649c5ce3cdea1e546259f4ca606a637
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/common.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/conftest.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/conftest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e02f0d43b56943f11e2746899572e21c74cf358
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/conftest.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_alter_axes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_alter_axes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eea3f7c18825297e4f1bbdf382e3b1adaeef1d5a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_alter_axes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_api.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_api.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0cc79ec9699f38bfd2f623483578278d07fc389c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_api.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_arithmetic.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_arithmetic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..108c44211eaf672888eaba69152f403b29be8650
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_arithmetic.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:488ad499974a772ddc3114b71a7b97db4ec1920f45749f5b96748990818138e3
+size 112912
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_block_internals.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_block_internals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01c801f2378b2de7411b474de31d236b15779039
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_block_internals.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_constructors.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_constructors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b87d6e615258c0534ee5281444f7806583cee53e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_constructors.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9eefc229491346215d98cd15a95271c0bf1bf253e5127b8381a34ce4401e2d5
+size 195839
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_cumulative.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_cumulative.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb70eba6f931fc8cfc749cd24307d5445d14dc35
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_cumulative.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_iteration.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_iteration.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..57eebad41dc23c8858c8457cf4e68dbda1c3787f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_iteration.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_logical_ops.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_logical_ops.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79c244587b09222bd9eba7a7e6f60f297098c1fb
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_logical_ops.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_nonunique_indexes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_nonunique_indexes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..523658369c035f1a4621beb902dbc124938221d2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_nonunique_indexes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_npfuncs.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_npfuncs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6d5e449a5e0489359e1457aa6a4466b4d64f55c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_npfuncs.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_query_eval.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_query_eval.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6694800b0d7cd41b4ef9616b31b4ba8224e9c688
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_query_eval.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_reductions.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_reductions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eab4d96cbf4068356c29988156c6b7253e8e6679
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_reductions.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e80dd1ef4ab2df0fc4584243ae4be99fb2059abfb8fe6640a73e086daa06069
+size 104490
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_repr_info.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_repr_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72c80fa4c92c02b0cb5a8c0e43614c4c04a5adf1
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_repr_info.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_stack_unstack.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_stack_unstack.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..deb6c48b42ea9d62223697ddd5a6496592611a60
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_stack_unstack.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cca7bfe41b7f39c2115c07917a272251d0b4272aef6a52ad2f50aa17bc01ea1
+size 126345
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_subclass.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_subclass.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfd9c6854ebd489191e51d14d9ea5c844608f1f7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_subclass.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_ufunc.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_ufunc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..607ed6278a5c946be16855430e6ff4f85014d9df
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_ufunc.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_unary.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_unary.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c6cdba879381c55fec80f9db6b3b1686927a84ed
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_unary.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_validate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_validate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3735b2a76d831e18ea916757055b9ada2348eca3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/__pycache__/test_validate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c74885b290a87364c522fba481e2bdb9a0f9da6b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/test_from_dict.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/test_from_dict.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6edbbf74a14f3af492b4fb1a1e493d01c3a40aa
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/test_from_dict.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/test_from_records.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/test_from_records.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c6fed05179d28c78f6375da7d55f0692f8753e5a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/constructors/__pycache__/test_from_records.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43948bee9014c832b5d70ece18434d3870e97543
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_coercion.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_coercion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d59861c3c79f44b3c417b11e8531d55802be36a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_coercion.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_delitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_delitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..686bbe38985e299de138a06194292df868fdcf1c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_delitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_get.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_get.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e14a938abc3ea93cda3ec8631a20b05729ee842
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_get.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_get_value.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_get_value.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f80917c5c6a2d72d85abb1365823768b187a6492
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_get_value.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_getitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_getitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb35030fbca3023112bd7eff8247ce4f89a13bf0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_getitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_indexing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_indexing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..803f75a57a3af8afb3df22ccf7a4c58e95864c7b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_indexing.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58893ec74aab606fa10a2132f237e7cd60211b37373ad81e3d1e58abf5bdd0a8
+size 109974
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_insert.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_insert.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7291696fb2dd579e62532c6a0b4731253b13996
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_insert.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_mask.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_mask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a4a8ca9d87d1c62d782d3da88c6567beb20b402
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_mask.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_set_value.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_set_value.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9328ef1b8b0634e79a46468ec398ccb0a1f4fbc5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_set_value.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_setitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_setitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..822f386c458b26ed5d77db153a5d9754de0c89c4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_setitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_take.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_take.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9185d07c79f08eddd58c9ff865dd551b50836a0b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_take.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_where.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_where.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76b6e324fa779066747674777e9564d9b46385f6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_where.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_xs.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_xs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99262ad7d9fb88d2b096dab6e4c338fc03c2a26d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/__pycache__/test_xs.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_coercion.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_coercion.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba0d8613b62287942f7fffeac96efe2abd0c9cd9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_coercion.py
@@ -0,0 +1,199 @@
+"""
+Tests for values coercion in setitem-like operations on DataFrame.
+
+For the most part, these should be multi-column DataFrames, otherwise
+we would share the tests with Series.
+"""
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameSetitemCoercion:
+    @pytest.mark.parametrize("consolidate", [True, False])
+    def test_loc_setitem_multiindex_columns(self, consolidate):
+        # GH#18415 Setting values in a single column preserves dtype,
+        #  while setting them in multiple columns did unwanted cast.
+
+        # Note that A here has 2 blocks, below we do the same thing
+        #  with a consolidated frame.
+        A = DataFrame(np.zeros((6, 5), dtype=np.float32))
+        A = pd.concat([A, A], axis=1, keys=[1, 2])
+        if consolidate:
+            A = A._consolidate()
+
+        A.loc[2:3, (1, slice(2, 3))] = np.ones((2, 2), dtype=np.float32)
+        assert (A.dtypes == np.float32).all()
+
+        A.loc[0:5, (1, slice(2, 3))] = np.ones((6, 2), dtype=np.float32)
+
+        assert (A.dtypes == np.float32).all()
+
+        A.loc[:, (1, slice(2, 3))] = np.ones((6, 2), dtype=np.float32)
+        assert (A.dtypes == np.float32).all()
+
+        # TODO: i think this isn't about MultiIndex and could be done with iloc?
+
+
+def test_37477():
+    # fixed by GH#45121
+    orig = DataFrame({"A": [1, 2, 3], "B": [3, 4, 5]})
+    expected = DataFrame({"A": [1, 2, 3], "B": [3, 1.2, 5]})
+
+    df = orig.copy()
+    with tm.assert_produces_warning(
+        FutureWarning, match="Setting an item of incompatible dtype"
+    ):
+        df.at[1, "B"] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+    df = orig.copy()
+    with tm.assert_produces_warning(
+        FutureWarning, match="Setting an item of incompatible dtype"
+    ):
+        df.loc[1, "B"] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+    df = orig.copy()
+    with tm.assert_produces_warning(
+        FutureWarning, match="Setting an item of incompatible dtype"
+    ):
+        df.iat[1, 1] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+    df = orig.copy()
+    with tm.assert_produces_warning(
+        FutureWarning, match="Setting an item of incompatible dtype"
+    ):
+        df.iloc[1, 1] = 1.2
+    tm.assert_frame_equal(df, expected)
+
+
+def test_6942(indexer_al):
+    # check that the .at __setitem__ after setting "Live" actually sets the data
+    start = Timestamp("2014-04-01")
+    t1 = Timestamp("2014-04-23 12:42:38.883082")
+    t2 = Timestamp("2014-04-24 01:33:30.040039")
+
+    dti = date_range(start, periods=1)
+    orig = DataFrame(index=dti, columns=["timenow", "Live"])
+
+    df = orig.copy()
+    indexer_al(df)[start, "timenow"] = t1
+
+    df["Live"] = True
+
+    df.at[start, "timenow"] = t2
+    assert df.iloc[0, 0] == t2
+
+
+def test_26395(indexer_al):
+    # .at case fixed by GH#45121 (best guess)
+    df = DataFrame(index=["A", "B", "C"])
+    df["D"] = 0
+
+    indexer_al(df)["C", "D"] = 2
+    expected = DataFrame({"D": [0, 0, 2]}, index=["A", "B", "C"], dtype=np.int64)
+    tm.assert_frame_equal(df, expected)
+
+    with tm.assert_produces_warning(
+        FutureWarning, match="Setting an item of incompatible dtype"
+    ):
+        indexer_al(df)["C", "D"] = 44.5
+    expected = DataFrame({"D": [0, 0, 44.5]}, index=["A", "B", "C"], dtype=np.float64)
+    tm.assert_frame_equal(df, expected)
+
+    with tm.assert_produces_warning(
+        FutureWarning, match="Setting an item of incompatible dtype"
+    ):
+        indexer_al(df)["C", "D"] = "hello"
+    expected = DataFrame({"D": [0, 0, "hello"]}, index=["A", "B", "C"], dtype=object)
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.xfail(reason="unwanted upcast")
+def test_15231():
+    df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"])
+    df.loc[2] = Series({"a": 5, "b": 6})
+    assert (df.dtypes == np.int64).all()
+
+    df.loc[3] = Series({"a": 7})
+
+    # df["a"] doesn't have any NaNs, should not have been cast
+    exp_dtypes = Series([np.int64, np.float64], dtype=object, index=["a", "b"])
+    tm.assert_series_equal(df.dtypes, exp_dtypes)
+
+
+def test_iloc_setitem_unnecesssary_float_upcasting():
+    # GH#12255
+    df = DataFrame(
+        {
+            0: np.array([1, 3], dtype=np.float32),
+            1: np.array([2, 4], dtype=np.float32),
+            2: ["a", "b"],
+        }
+    )
+    orig = df.copy()
+
+    values = df[0].values.reshape(2, 1)
+    df.iloc[:, 0:1] = values
+
+    tm.assert_frame_equal(df, orig)
+
+
+@pytest.mark.xfail(reason="unwanted casting to dt64")
+def test_12499():
+    # TODO: OP in GH#12499 used np.datetim64("NaT") instead of pd.NaT,
+    #  which has consequences for the expected df["two"] (though i think at
+    #  the time it might not have because of a separate bug). See if it makes
+    #  a difference which one we use here.
+    ts = Timestamp("2016-03-01 03:13:22.98986", tz="UTC")
+
+    data = [{"one": 0, "two": ts}]
+    orig = DataFrame(data)
+    df = orig.copy()
+    df.loc[1] = [np.nan, NaT]
+
+    expected = DataFrame(
+        {"one": [0, np.nan], "two": Series([ts, NaT], dtype="datetime64[ns, UTC]")}
+    )
+    tm.assert_frame_equal(df, expected)
+
+    data = [{"one": 0, "two": ts}]
+    df = orig.copy()
+    df.loc[1, :] = [np.nan, NaT]
+    tm.assert_frame_equal(df, expected)
+
+
+def test_20476():
+    mi = MultiIndex.from_product([["A", "B"], ["a", "b", "c"]])
+    df = DataFrame(-1, index=range(3), columns=mi)
+    filler = DataFrame([[1, 2, 3.0]] * 3, index=range(3), columns=["a", "b", "c"])
+    df["A"] = filler
+
+    expected = DataFrame(
+        {
+            0: [1, 1, 1],
+            1: [2, 2, 2],
+            2: [3.0, 3.0, 3.0],
+            3: [-1, -1, -1],
+            4: [-1, -1, -1],
+            5: [-1, -1, -1],
+        }
+    )
+    expected.columns = mi
+    exp_dtypes = Series(
+        [np.dtype(np.int64)] * 2 + [np.dtype(np.float64)] + [np.dtype(np.int64)] * 3,
+        index=mi,
+    )
+    tm.assert_series_equal(df.dtypes, exp_dtypes)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_delitem.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_delitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..daec991b7a8dbf8de0221f041e767cb9ce58ae29
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_delitem.py
@@ -0,0 +1,60 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+
+
+class TestDataFrameDelItem:
+    def test_delitem(self, float_frame):
+        del float_frame["A"]
+        assert "A" not in float_frame
+
+    def test_delitem_multiindex(self):
+        midx = MultiIndex.from_product([["A", "B"], [1, 2]])
+        df = DataFrame(np.random.default_rng(2).standard_normal((4, 4)), columns=midx)
+        assert len(df.columns) == 4
+        assert ("A",) in df.columns
+        assert "A" in df.columns
+
+        result = df["A"]
+        assert isinstance(result, DataFrame)
+        del df["A"]
+
+        assert len(df.columns) == 2
+
+        # A still in the levels, BUT get a KeyError if trying
+        # to delete
+        assert ("A",) not in df.columns
+        with pytest.raises(KeyError, match=re.escape("('A',)")):
+            del df[("A",)]
+
+        # behavior of dropped/deleted MultiIndex levels changed from
+        # GH 2770 to GH 19027: MultiIndex no longer '.__contains__'
+        # levels which are dropped/deleted
+        assert "A" not in df.columns
+        with pytest.raises(KeyError, match=re.escape("('A',)")):
+            del df["A"]
+
+    def test_delitem_corner(self, float_frame):
+        f = float_frame.copy()
+        del f["D"]
+        assert len(f.columns) == 3
+        with pytest.raises(KeyError, match=r"^'D'$"):
+            del f["D"]
+        del f["B"]
+        assert len(f.columns) == 2
+
+    def test_delitem_col_still_multiindex(self):
+        arrays = [["a", "b", "c", "top"], ["", "", "", "OD"], ["", "", "", "wx"]]
+
+        tuples = sorted(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((3, 4)), columns=index)
+        del df[("a", "", "")]
+        assert isinstance(df.columns, MultiIndex)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_get_value.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_get_value.py
new file mode 100644
index 0000000000000000000000000000000000000000..65a1c64a1578ad0cadd9ed6470ab60a2087ffec5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_get_value.py
@@ -0,0 +1,22 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+
+
+class TestGetValue:
+    def test_get_set_value_no_partial_indexing(self):
+        # partial w/ MultiIndex raise exception
+        index = MultiIndex.from_tuples([(0, 1), (0, 2), (1, 1), (1, 2)])
+        df = DataFrame(index=index, columns=range(4))
+        with pytest.raises(KeyError, match=r"^0$"):
+            df._get_value(0, 1)
+
+    def test_get_value(self, float_frame):
+        for idx in float_frame.index:
+            for col in float_frame.columns:
+                result = float_frame._get_value(idx, col)
+                expected = float_frame[col][idx]
+                assert result == expected
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_getitem.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_getitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d9324f557c8d4056042f830af752872f35f9f63
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/indexing/test_getitem.py
@@ -0,0 +1,478 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    CategoricalDtype,
+    CategoricalIndex,
+    DataFrame,
+    DateOffset,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+    get_dummies,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import SparseArray
+
+
+class TestGetitem:
+    def test_getitem_unused_level_raises(self):
+        # GH#20410
+        mi = MultiIndex(
+            levels=[["a_lot", "onlyone", "notevenone"], [1970, ""]],
+            codes=[[1, 0], [1, 0]],
+        )
+        df = DataFrame(-1, index=range(3), columns=mi)
+
+        with pytest.raises(KeyError, match="notevenone"):
+            df["notevenone"]
+
+    def test_getitem_periodindex(self):
+        rng = period_range("1/1/2000", periods=5)
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 5)), columns=rng)
+
+        ts = df[rng[0]]
+        tm.assert_series_equal(ts, df.iloc[:, 0])
+
+        # GH#1211; smoketest unrelated to the rest of this test
+        repr(df)
+
+        ts = df["1/1/2000"]
+        tm.assert_series_equal(ts, df.iloc[:, 0])
+
+    def test_getitem_list_of_labels_categoricalindex_cols(self):
+        # GH#16115
+        cats = Categorical([Timestamp("12-31-1999"), Timestamp("12-31-2000")])
+
+        expected = DataFrame([[1, 0], [0, 1]], dtype="bool", index=[0, 1], columns=cats)
+        dummies = get_dummies(cats)
+        result = dummies[list(dummies.columns)]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_sparse_column_return_type_and_dtype(self):
+        # https://github.com/pandas-dev/pandas/issues/23559
+        data = SparseArray([0, 1])
+        df = DataFrame({"A": data})
+        expected = Series(data, name="A")
+        result = df["A"]
+        tm.assert_series_equal(result, expected)
+
+        # Also check iloc and loc while we're here
+        result = df.iloc[:, 0]
+        tm.assert_series_equal(result, expected)
+
+        result = df.loc[:, "A"]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_string_columns(self):
+        # GH#46185
+        df = DataFrame([[1, 2]], columns=Index(["A", "B"], dtype="string"))
+        result = df.A
+        expected = df["A"]
+        tm.assert_series_equal(result, expected)
+
+
+class TestGetitemListLike:
+    def test_getitem_list_missing_key(self):
+        # GH#13822, incorrect error string with non-unique columns when missing
+        # column is accessed
+        df = DataFrame({"x": [1.0], "y": [2.0], "z": [3.0]})
+        df.columns = ["x", "x", "z"]
+
+        # Check that we get the correct value in the KeyError
+        with pytest.raises(KeyError, match=r"\['y'\] not in index"):
+            df[["x", "y", "z"]]
+
+    def test_getitem_list_duplicates(self):
+        # GH#1943
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)), columns=list("AABC")
+        )
+        df.columns.name = "foo"
+
+        result = df[["B", "C"]]
+        assert result.columns.name == "foo"
+
+        expected = df.iloc[:, 2:]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_dupe_cols(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
+        msg = "\"None of [Index(['baf'], dtype='object')] are in the [columns]\""
+        with pytest.raises(KeyError, match=re.escape(msg)):
+            df[["baf"]]
+
+    @pytest.mark.parametrize(
+        "idx_type",
+        [
+            list,
+            iter,
+            Index,
+            set,
+            lambda keys: dict(zip(keys, range(len(keys)))),
+            lambda keys: dict(zip(keys, range(len(keys)))).keys(),
+        ],
+        ids=["list", "iter", "Index", "set", "dict", "dict_keys"],
+    )
+    @pytest.mark.parametrize("levels", [1, 2])
+    def test_getitem_listlike(self, idx_type, levels, float_frame):
+        # GH#21294
+
+        if levels == 1:
+            frame, missing = float_frame, "food"
+        else:
+            # MultiIndex columns
+            frame = DataFrame(
+                np.random.default_rng(2).standard_normal((8, 3)),
+                columns=Index(
+                    [("foo", "bar"), ("baz", "qux"), ("peek", "aboo")],
+                    name=("sth", "sth2"),
+                ),
+            )
+            missing = ("good", "food")
+
+        keys = [frame.columns[1], frame.columns[0]]
+        idx = idx_type(keys)
+        idx_check = list(idx_type(keys))
+
+        if isinstance(idx, (set, dict)):
+            with pytest.raises(TypeError, match="as an indexer is not supported"):
+                frame[idx]
+
+            return
+        else:
+            result = frame[idx]
+
+        expected = frame.loc[:, idx_check]
+        expected.columns.names = frame.columns.names
+
+        tm.assert_frame_equal(result, expected)
+
+        idx = idx_type(keys + [missing])
+        with pytest.raises(KeyError, match="not in index"):
+            frame[idx]
+
+    def test_getitem_iloc_generator(self):
+        # GH#39614
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        indexer = (x for x in [1, 2])
+        result = df.iloc[indexer]
+        expected = DataFrame({"a": [2, 3], "b": [5, 6]}, index=[1, 2])
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_iloc_two_dimensional_generator(self):
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        indexer = (x for x in [1, 2])
+        result = df.iloc[indexer, 1]
+        expected = Series([5, 6], name="b", index=[1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_iloc_dateoffset_days(self):
+        # GH 46671
+        df = DataFrame(
+            list(range(10)),
+            index=date_range("01-01-2022", periods=10, freq=DateOffset(days=1)),
+        )
+        result = df.loc["2022-01-01":"2022-01-03"]
+        expected = DataFrame(
+            [0, 1, 2],
+            index=DatetimeIndex(
+                ["2022-01-01", "2022-01-02", "2022-01-03"],
+                dtype="datetime64[ns]",
+                freq=DateOffset(days=1),
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            list(range(10)),
+            index=date_range(
+                "01-01-2022", periods=10, freq=DateOffset(days=1, hours=2)
+            ),
+        )
+        result = df.loc["2022-01-01":"2022-01-03"]
+        expected = DataFrame(
+            [0, 1, 2],
+            index=DatetimeIndex(
+                ["2022-01-01 00:00:00", "2022-01-02 02:00:00", "2022-01-03 04:00:00"],
+                dtype="datetime64[ns]",
+                freq=DateOffset(days=1, hours=2),
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            list(range(10)),
+            index=date_range("01-01-2022", periods=10, freq=DateOffset(minutes=3)),
+        )
+        result = df.loc["2022-01-01":"2022-01-03"]
+        tm.assert_frame_equal(result, df)
+
+
+class TestGetitemCallable:
+    def test_getitem_callable(self, float_frame):
+        # GH#12533
+        result = float_frame[lambda x: "A"]
+        expected = float_frame.loc[:, "A"]
+        tm.assert_series_equal(result, expected)
+
+        result = float_frame[lambda x: ["A", "B"]]
+        expected = float_frame.loc[:, ["A", "B"]]
+        tm.assert_frame_equal(result, float_frame.loc[:, ["A", "B"]])
+
+        df = float_frame[:3]
+        result = df[lambda x: [True, False, True]]
+        expected = float_frame.iloc[[0, 2], :]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_multiindex_columns_one_level(self):
+        # GH#29749
+        df = DataFrame([[1, 2]], columns=[["a", "b"]])
+        expected = DataFrame([1], columns=[["a"]])
+
+        result = df["a"]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc[:, "a"]
+        tm.assert_frame_equal(result, expected)
+
+
+class TestGetitemBooleanMask:
+    def test_getitem_bool_mask_categorical_index(self):
+        df3 = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+            },
+            index=CategoricalIndex(
+                [1, 1, 2, 1, 3, 2],
+                dtype=CategoricalDtype([3, 2, 1], ordered=True),
+                name="B",
+            ),
+        )
+        df4 = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+            },
+            index=CategoricalIndex(
+                [1, 1, 2, 1, 3, 2],
+                dtype=CategoricalDtype([3, 2, 1], ordered=False),
+                name="B",
+            ),
+        )
+
+        result = df3[df3.index == "a"]
+        expected = df3.iloc[[]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df4[df4.index == "a"]
+        expected = df4.iloc[[]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df3[df3.index == 1]
+        expected = df3.iloc[[0, 1, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df4[df4.index == 1]
+        expected = df4.iloc[[0, 1, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        # since we have an ordered categorical
+
+        # CategoricalIndex([1, 1, 2, 1, 3, 2],
+        #         categories=[3, 2, 1],
+        #         ordered=True,
+        #         name='B')
+        result = df3[df3.index < 2]
+        expected = df3.iloc[[4]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df3[df3.index > 1]
+        expected = df3.iloc[[]]
+        tm.assert_frame_equal(result, expected)
+
+        # unordered
+        # cannot be compared
+
+        # CategoricalIndex([1, 1, 2, 1, 3, 2],
+        #         categories=[3, 2, 1],
+        #         ordered=False,
+        #         name='B')
+        msg = "Unordered Categoricals can only compare equality or not"
+        with pytest.raises(TypeError, match=msg):
+            df4[df4.index < 2]
+        with pytest.raises(TypeError, match=msg):
+            df4[df4.index > 1]
+
+    @pytest.mark.parametrize(
+        "data1,data2,expected_data",
+        (
+            (
+                [[1, 2], [3, 4]],
+                [[0.5, 6], [7, 8]],
+                [[np.nan, 3.0], [np.nan, 4.0], [np.nan, 7.0], [6.0, 8.0]],
+            ),
+            (
+                [[1, 2], [3, 4]],
+                [[5, 6], [7, 8]],
+                [[np.nan, 3.0], [np.nan, 4.0], [5, 7], [6, 8]],
+            ),
+        ),
+    )
+    def test_getitem_bool_mask_duplicate_columns_mixed_dtypes(
+        self,
+        data1,
+        data2,
+        expected_data,
+    ):
+        # GH#31954
+
+        df1 = DataFrame(np.array(data1))
+        df2 = DataFrame(np.array(data2))
+        df = concat([df1, df2], axis=1)
+
+        result = df[df > 2]
+
+        exdict = {i: np.array(col) for i, col in enumerate(expected_data)}
+        expected = DataFrame(exdict).rename(columns={2: 0, 3: 1})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.fixture
+    def df_dup_cols(self):
+        dups = ["A", "A", "C", "D"]
+        df = DataFrame(np.arange(12).reshape(3, 4), columns=dups, dtype="float64")
+        return df
+
+    def test_getitem_boolean_frame_unaligned_with_duplicate_columns(self, df_dup_cols):
+        # `df.A > 6` is a DataFrame with a different shape from df
+
+        # boolean with the duplicate raises
+        df = df_dup_cols
+        msg = "cannot reindex on an axis with duplicate labels"
+        with pytest.raises(ValueError, match=msg):
+            df[df.A > 6]
+
+    def test_getitem_boolean_series_with_duplicate_columns(self, df_dup_cols):
+        # boolean indexing
+        # GH#4879
+        df = DataFrame(
+            np.arange(12).reshape(3, 4), columns=["A", "B", "C", "D"], dtype="float64"
+        )
+        expected = df[df.C > 6]
+        expected.columns = df_dup_cols.columns
+
+        df = df_dup_cols
+        result = df[df.C > 6]
+
+        tm.assert_frame_equal(result, expected)
+        result.dtypes
+        str(result)
+
+    def test_getitem_boolean_frame_with_duplicate_columns(self, df_dup_cols):
+        # where
+        df = DataFrame(
+            np.arange(12).reshape(3, 4), columns=["A", "B", "C", "D"], dtype="float64"
+        )
+        # `df > 6` is a DataFrame with the same shape+alignment as df
+        expected = df[df > 6]
+        expected.columns = df_dup_cols.columns
+
+        df = df_dup_cols
+        result = df[df > 6]
+
+        tm.assert_frame_equal(result, expected)
+        result.dtypes
+        str(result)
+
+    def test_getitem_empty_frame_with_boolean(self):
+        # Test for issue GH#11859
+
+        df = DataFrame()
+        df2 = df[df > 0]
+        tm.assert_frame_equal(df, df2)
+
+    def test_getitem_returns_view_when_column_is_unique_in_df(
+        self, using_copy_on_write
+    ):
+        # GH#45316
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
+        df_orig = df.copy()
+        view = df["b"]
+        view.loc[:] = 100
+        if using_copy_on_write:
+            expected = df_orig
+        else:
+            expected = DataFrame([[1, 2, 100], [4, 5, 100]], columns=["a", "a", "b"])
+        tm.assert_frame_equal(df, expected)
+
+    def test_getitem_frozenset_unique_in_column(self):
+        # GH#41062
+        df = DataFrame([[1, 2, 3, 4]], columns=[frozenset(["KEY"]), "B", "C", "C"])
+        result = df[frozenset(["KEY"])]
+        expected = Series([1], name=frozenset(["KEY"]))
+        tm.assert_series_equal(result, expected)
+
+
+class TestGetitemSlice:
+    def test_getitem_slice_float64(self, frame_or_series):
+        values = np.arange(10.0, 50.0, 2)
+        index = Index(values)
+
+        start, end = values[[5, 15]]
+
+        data = np.random.default_rng(2).standard_normal((20, 3))
+        if frame_or_series is not DataFrame:
+            data = data[:, 0]
+
+        obj = frame_or_series(data, index=index)
+
+        result = obj[start:end]
+        expected = obj.iloc[5:16]
+        tm.assert_equal(result, expected)
+
+        result = obj.loc[start:end]
+        tm.assert_equal(result, expected)
+
+    def test_getitem_datetime_slice(self):
+        # GH#43223
+        df = DataFrame(
+            {"a": 0},
+            index=DatetimeIndex(
+                [
+                    "11.01.2011 22:00",
+                    "11.01.2011 23:00",
+                    "12.01.2011 00:00",
+                    "2011-01-13 00:00",
+                ]
+            ),
+        )
+        with pytest.raises(
+            KeyError, match="Value based partial slicing on non-monotonic"
+        ):
+            df["2011-01-01":"2011-11-01"]
+
+    def test_getitem_slice_same_dim_only_one_axis(self):
+        # GH#54622
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 8)))
+        result = df.iloc[(slice(None, None, 2),)]
+        assert result.shape == (5, 8)
+        expected = df.iloc[slice(None, None, 2), slice(None)]
+        tm.assert_frame_equal(result, expected)
+
+
+class TestGetitemDeprecatedIndexers:
+    @pytest.mark.parametrize("key", [{"a", "b"}, {"a": "a"}])
+    def test_getitem_dict_and_set_deprecated(self, key):
+        # GH#42825 enforced in 2.0
+        df = DataFrame(
+            [[1, 2], [3, 4]], columns=MultiIndex.from_tuples([("a", 1), ("b", 2)])
+        )
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            df[key]
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..245594bfdc9e72ff5cb3a4799e9055c7cd6b5a3e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__init__.py
@@ -0,0 +1,7 @@
+"""
+Test files dedicated to individual (stand-alone) DataFrame methods
+
+Ideally these files/tests should correspond 1-to-1 with tests.series.methods
+
+These may also present opportunities for sharing/de-duplicating test code.
+"""
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a2cae9e6b40970c21fe9422c6324a3e5d3989777
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e6f38ab5038c9acd1c0db6fe25465df101752b0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_align.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_align.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e3b05624bc7e1961337d00984db2af42089196d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_align.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..750bcd4154aabe299aad3acef2432852f22cd37d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_asfreq.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_asof.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_asof.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..50970cb829823b8808bbc770c3acad028e17428c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_asof.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_assign.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_assign.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22f30f8e80e8a974dd6cece1a44074bacb32e8bc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_assign.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_astype.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_astype.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67256bc0c0865e1f4c526892c9f783cfaac5aeb6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_astype.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_at_time.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_at_time.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ff187f6b6b6e239968f06a634e5ebdf9e71d777
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_at_time.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_between_time.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_between_time.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e87b292887d6772b32074e334cd8268d58824c86
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_between_time.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_clip.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_clip.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e751bf66322691f980d17630d92dc91a7ebcf7a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_clip.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_combine.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_combine.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b22c21e9cf8330121454124b107ceeddc3f4960d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_combine.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4e12185ec4a764d2341183a86f92e7b071da7aa
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_combine_first.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_compare.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_compare.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb76d18382f4be05ccc099a0a38ab2086a699d19
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_compare.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_convert_dtypes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_convert_dtypes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..47fdf1881164159d2495a744fbf883293caabd6a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_convert_dtypes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_copy.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_copy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e6c49ffe22d3f34200639949a88db3d68dabf2a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_copy.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_count.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_count.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65d957f7e02be25155d78309b80a99e7a27f5beb
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_count.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c56478b50933c9e375d879497e0ac1a2778730e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_cov_corr.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_describe.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_describe.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5be1b300f511e392bd8ec94856636fa8a9c24ccd
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_describe.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_diff.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbfc67b4fe2e5fa79e34b921c5f04ac37ad6c6e2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_diff.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dot.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dot.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdae3ec80ef13898f8ef79bb1520a8022b1948da
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dot.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_drop.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_drop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e34cf73a206879619c6d8595f0027c9caa14b97
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_drop.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_drop_duplicates.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_drop_duplicates.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65f351ff38dd41e7e13afb9aa68d6b644f434c5b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_drop_duplicates.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b722de68913e403bdd5b0bdb822fc4b63ac8c17
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_droplevel.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dropna.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dropna.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63e5180e227a4d67d32570f31fce06a4ab75ffde
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dropna.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36adeb307f873a54986b7b6e0a85bc8d1de4c584
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_dtypes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_duplicated.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_duplicated.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1fe689561515cbb2c5c5c55c5b2f99f3ae41bec5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_duplicated.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_equals.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_equals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6b3959ca6a1333f5b5ec4c76d2e7b46cf7d1733
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_equals.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_explode.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_explode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3858d24463fc5e05551a762fb6209ba82b48a21a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_explode.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_fillna.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_fillna.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71e7306ab58efe935729e4a98f16bc641f7ed9b3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_fillna.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_filter.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_filter.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8feed2e9abef64838fedce2bd2c0fb786bf73f17
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_filter.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e935d2160148e047e37bc03e9c6a8fbaf38f9a8b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_first_and_last.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..68d0438590ccf1af2332120949dc8ac5b796f5f9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_first_valid_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b74cfa31a90058f1f0df2648ca5ea08831f18188
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_get_numeric_data.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_head_tail.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_head_tail.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3ae6c3a02b3a2d37ab389cc0b7b930819a4dddc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_head_tail.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_infer_objects.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_infer_objects.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64718c6b164e7370219264a0f3352bea5c2e543a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_infer_objects.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d63c48f58543e6f683bab6f9b732529c4d2e2eb
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_interpolate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..155e7e8e16267ff41db767706912090f5ee52e64
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_is_homogeneous_dtype.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5055499f11477002ba2d7ac3142684b048319d70
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_isetitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_isin.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_isin.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6838d374abbc82e02f5c7d2f26abcafb9e0e1121
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_isin.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_iterrows.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_iterrows.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1efd97a53d5fb188e19ad637e5a3af628019f19c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_iterrows.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_join.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_join.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8c091f9e06452a102db8b0642a30fb40f12f5b0b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_join.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_map.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_map.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..857d75ecc3cf83e7e0047b1a44df9d3d2ee7a530
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_map.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_matmul.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_matmul.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5af393be40c4c79d24f6b344d117c87c282c374
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_matmul.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_nlargest.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_nlargest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a32916f28536cb3f2233e66a8c1a76099d40d38
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_nlargest.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9fb3898aca5ce830821c73236d005552ebca9b2b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pct_change.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pipe.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pipe.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..497b568af02d9e66ccb0ae3f7c2a39ffd99e4376
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pipe.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pop.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1fa2fa2bfc5ea65558a24c7b7fb567cd5bb756a4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_pop.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_quantile.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_quantile.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5f4388f7be2e2d2a9d55b062c4be86674a36aed
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_quantile.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rank.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rank.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..40258a64273e657ab7fb9fe3f82e5c2263d7ef44
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rank.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9164f3585c86ab301535336c85524396eae3328f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..418a10051f3e4d29829c420991f6e17013a5baae
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reindex_like.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rename.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rename.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb71cda20d3da257ec0d2efb2d008f7ed6091f79
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rename.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71e8a877e6f6b1b12a581127a6538d89b822775e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_rename_axis.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reorder_levels.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reorder_levels.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb2abbaf3404624f737b70f56dcc69da474bbab5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reorder_levels.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_replace.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_replace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dab3adfcc01d1c48e6abf58c4b4c76542476ba69
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_replace.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a078185e8cbba919aca54149ebe980874f5b3513
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_reset_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_round.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_round.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4cd1e60c77c6f7d4e4a9abbae8f2c410a003f489
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_round.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sample.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sample.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..562b1cecbc31dce91cd93859d77488cad09d842d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sample.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1b5d950eacdcc50de4869e2d02b8f1600a203b4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_select_dtypes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_set_axis.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_set_axis.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7de2e35b33ad8bdc02d80223409763542526357d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_set_axis.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_set_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_set_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a35589d48016432324010f5690525eff345f29d7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_set_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_shift.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_shift.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2e6cbfdbdbcc1f3a2a2542b68c1a3efc7c654b4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_shift.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_size.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_size.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a730038adf339eb2e1882cc43bc8949ab2054a4f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_size.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f098870bf8a28fd04a3c7b017d0fc655af3fabd
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2596d558dc43be2c966bb8e6fcf80285a33b476
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_sort_values.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b53c324828092106be6f1486d78d6ed30b90807
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_swapaxes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef01ef70e52212255567fd8bd8621e8cc5b9f6e5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_swaplevel.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85d37d429ba1fbd89902af1ddeba7651c36f24fd
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_csv.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca9a88f0715a81f474861213c8eb60c2d6c3f1b0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17f4d86f8f18947a4018307094e95f81cf62b682
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_dict_of_blocks.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4082d52a2b5e10a928bac3c376e961af76bbca6b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_numpy.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_period.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_period.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c6787f957876d70c5a7abac7db2c3fa2ad10082
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_period.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_records.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_records.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4751df7543b43580dc22b7e5dd67479ff4ff2c37
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_records.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65d4b4266b556ca70af4055f78b9cc90edf49607
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_to_timestamp.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_transpose.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_transpose.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7533413d0b06d4940ec30f5d3bc363ae7d0ab92e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_transpose.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_truncate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_truncate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f577ea197824d2e9eb952bdf832590e0b84b7720
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_truncate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30eb69e99709e4354c9d3a8764e6f2e723bebf25
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_convert.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e8cd6dda9b722901181c462eb4a5a714189131a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_tz_localize.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_update.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_update.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c47f0413d42659655533e30a0d3bd42aed47ea9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_update.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc11673a86e41064942d3695e28d3aa480785ccb
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_value_counts.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_values.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_values.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2023c7f2745274634769ceefe3a8e9ccabaf6874
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/__pycache__/test_values.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_add_prefix_suffix.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_add_prefix_suffix.py
new file mode 100644
index 0000000000000000000000000000000000000000..92d7cdd7990e168721610b7f52f653a69ac1e078
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_add_prefix_suffix.py
@@ -0,0 +1,49 @@
+import pytest
+
+from pandas import Index
+import pandas._testing as tm
+
+
+def test_add_prefix_suffix(float_frame):
+    with_prefix = float_frame.add_prefix("foo#")
+    expected = Index([f"foo#{c}" for c in float_frame.columns])
+    tm.assert_index_equal(with_prefix.columns, expected)
+
+    with_suffix = float_frame.add_suffix("#foo")
+    expected = Index([f"{c}#foo" for c in float_frame.columns])
+    tm.assert_index_equal(with_suffix.columns, expected)
+
+    with_pct_prefix = float_frame.add_prefix("%")
+    expected = Index([f"%{c}" for c in float_frame.columns])
+    tm.assert_index_equal(with_pct_prefix.columns, expected)
+
+    with_pct_suffix = float_frame.add_suffix("%")
+    expected = Index([f"{c}%" for c in float_frame.columns])
+    tm.assert_index_equal(with_pct_suffix.columns, expected)
+
+
+def test_add_prefix_suffix_axis(float_frame):
+    # GH 47819
+    with_prefix = float_frame.add_prefix("foo#", axis=0)
+    expected = Index([f"foo#{c}" for c in float_frame.index])
+    tm.assert_index_equal(with_prefix.index, expected)
+
+    with_prefix = float_frame.add_prefix("foo#", axis=1)
+    expected = Index([f"foo#{c}" for c in float_frame.columns])
+    tm.assert_index_equal(with_prefix.columns, expected)
+
+    with_pct_suffix = float_frame.add_suffix("#foo", axis=0)
+    expected = Index([f"{c}#foo" for c in float_frame.index])
+    tm.assert_index_equal(with_pct_suffix.index, expected)
+
+    with_pct_suffix = float_frame.add_suffix("#foo", axis=1)
+    expected = Index([f"{c}#foo" for c in float_frame.columns])
+    tm.assert_index_equal(with_pct_suffix.columns, expected)
+
+
+def test_add_prefix_suffix_invalid_axis(float_frame):
+    with pytest.raises(ValueError, match="No axis named 2 for object type DataFrame"):
+        float_frame.add_prefix("foo#", axis=2)
+
+    with pytest.raises(ValueError, match="No axis named 2 for object type DataFrame"):
+        float_frame.add_suffix("foo#", axis=2)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_align.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_align.py
new file mode 100644
index 0000000000000000000000000000000000000000..87a56c07362879e54ef03e28d1b2b06cdb4236dd
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_align.py
@@ -0,0 +1,490 @@
+from datetime import timezone
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameAlign:
+    def test_align_asfreq_method_raises(self):
+        df = DataFrame({"A": [1, np.nan, 2]})
+        msg = "Invalid fill method"
+        msg2 = "The 'method', 'limit', and 'fill_axis' keywords"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                df.align(df.iloc[::-1], method="asfreq")
+
+    def test_frame_align_aware(self):
+        idx1 = date_range("2001", periods=5, freq="H", tz="US/Eastern")
+        idx2 = date_range("2001", periods=5, freq="2H", tz="US/Eastern")
+        df1 = DataFrame(np.random.default_rng(2).standard_normal((len(idx1), 3)), idx1)
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((len(idx2), 3)), idx2)
+        new1, new2 = df1.align(df2)
+        assert df1.index.tz == new1.index.tz
+        assert df2.index.tz == new2.index.tz
+
+        # different timezones convert to UTC
+
+        # frame with frame
+        df1_central = df1.tz_convert("US/Central")
+        new1, new2 = df1.align(df1_central)
+        assert new1.index.tz is timezone.utc
+        assert new2.index.tz is timezone.utc
+
+        # frame with Series
+        new1, new2 = df1.align(df1_central[0], axis=0)
+        assert new1.index.tz is timezone.utc
+        assert new2.index.tz is timezone.utc
+
+        df1[0].align(df1_central, axis=0)
+        assert new1.index.tz is timezone.utc
+        assert new2.index.tz is timezone.utc
+
+    def test_align_float(self, float_frame, using_copy_on_write):
+        af, bf = float_frame.align(float_frame)
+        assert af._mgr is not float_frame._mgr
+
+        af, bf = float_frame.align(float_frame, copy=False)
+        if not using_copy_on_write:
+            assert af._mgr is float_frame._mgr
+        else:
+            assert af._mgr is not float_frame._mgr
+
+        # axis = 0
+        other = float_frame.iloc[:-5, :3]
+        af, bf = float_frame.align(other, axis=0, fill_value=-1)
+
+        tm.assert_index_equal(bf.columns, other.columns)
+
+        # test fill value
+        join_idx = float_frame.index.join(other.index)
+        diff_a = float_frame.index.difference(join_idx)
+        diff_a_vals = af.reindex(diff_a).values
+        assert (diff_a_vals == -1).all()
+
+        af, bf = float_frame.align(other, join="right", axis=0)
+        tm.assert_index_equal(bf.columns, other.columns)
+        tm.assert_index_equal(bf.index, other.index)
+        tm.assert_index_equal(af.index, other.index)
+
+        # axis = 1
+        other = float_frame.iloc[:-5, :3].copy()
+        af, bf = float_frame.align(other, axis=1)
+        tm.assert_index_equal(bf.columns, float_frame.columns)
+        tm.assert_index_equal(bf.index, other.index)
+
+        # test fill value
+        join_idx = float_frame.index.join(other.index)
+        diff_a = float_frame.index.difference(join_idx)
+        diff_a_vals = af.reindex(diff_a).values
+
+        assert (diff_a_vals == -1).all()
+
+        af, bf = float_frame.align(other, join="inner", axis=1)
+        tm.assert_index_equal(bf.columns, other.columns)
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_frame.align(other, join="inner", axis=1, method="pad")
+        tm.assert_index_equal(bf.columns, other.columns)
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=None
+            )
+        tm.assert_index_equal(bf.index, Index([]))
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=0
+            )
+        tm.assert_index_equal(bf.index, Index([]))
+
+        # Try to align DataFrame to Series along bad axis
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            float_frame.align(af.iloc[0, :3], join="inner", axis=2)
+
+    def test_align_frame_with_series(self, float_frame):
+        # align dataframe to series with broadcast or not
+        idx = float_frame.index
+        s = Series(range(len(idx)), index=idx)
+
+        left, right = float_frame.align(s, axis=0)
+        tm.assert_index_equal(left.index, float_frame.index)
+        tm.assert_index_equal(right.index, float_frame.index)
+        assert isinstance(right, Series)
+
+        msg = "The 'broadcast_axis' keyword in DataFrame.align is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            left, right = float_frame.align(s, broadcast_axis=1)
+        tm.assert_index_equal(left.index, float_frame.index)
+        expected = {c: s for c in float_frame.columns}
+        expected = DataFrame(
+            expected, index=float_frame.index, columns=float_frame.columns
+        )
+        tm.assert_frame_equal(right, expected)
+
+    def test_align_series_condition(self):
+        # see gh-9558
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        result = df[df["a"] == 2]
+        expected = DataFrame([[2, 5]], index=[1], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+        result = df.where(df["a"] == 2, 0)
+        expected = DataFrame({"a": [0, 2, 0], "b": [0, 5, 0]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_align_int(self, int_frame):
+        # test other non-float types
+        other = DataFrame(index=range(5), columns=["A", "B", "C"])
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = int_frame.align(other, join="inner", axis=1, method="pad")
+        tm.assert_index_equal(bf.columns, other.columns)
+
+    def test_align_mixed_type(self, float_string_frame):
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_string_frame.align(
+                float_string_frame, join="inner", axis=1, method="pad"
+            )
+        tm.assert_index_equal(bf.columns, float_string_frame.columns)
+
+    def test_align_mixed_float(self, mixed_float_frame):
+        # mixed floats/ints
+        other = DataFrame(index=range(5), columns=["A", "B", "C"])
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = mixed_float_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=0
+            )
+        tm.assert_index_equal(bf.index, Index([]))
+
+    def test_align_mixed_int(self, mixed_int_frame):
+        other = DataFrame(index=range(5), columns=["A", "B", "C"])
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = mixed_int_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=0
+            )
+        tm.assert_index_equal(bf.index, Index([]))
+
+    @pytest.mark.parametrize(
+        "l_ordered,r_ordered,expected",
+        [
+            [True, True, pd.CategoricalIndex],
+            [True, False, Index],
+            [False, True, Index],
+            [False, False, pd.CategoricalIndex],
+        ],
+    )
+    def test_align_categorical(self, l_ordered, r_ordered, expected):
+        # GH-28397
+        df_1 = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+                "B": Series(list("aabbca")).astype(
+                    pd.CategoricalDtype(list("cab"), ordered=l_ordered)
+                ),
+            }
+        ).set_index("B")
+        df_2 = DataFrame(
+            {
+                "A": np.arange(5, dtype="int64"),
+                "B": Series(list("babca")).astype(
+                    pd.CategoricalDtype(list("cab"), ordered=r_ordered)
+                ),
+            }
+        ).set_index("B")
+
+        aligned_1, aligned_2 = df_1.align(df_2)
+        assert isinstance(aligned_1.index, expected)
+        assert isinstance(aligned_2.index, expected)
+        tm.assert_index_equal(aligned_1.index, aligned_2.index)
+
+    def test_align_multiindex(self):
+        # GH#10665
+        # same test cases as test_align_multiindex in test_series.py
+
+        midx = pd.MultiIndex.from_product(
+            [range(2), range(3), range(2)], names=("a", "b", "c")
+        )
+        idx = Index(range(2), name="b")
+        df1 = DataFrame(np.arange(12, dtype="int64"), index=midx)
+        df2 = DataFrame(np.arange(2, dtype="int64"), index=idx)
+
+        # these must be the same results (but flipped)
+        res1l, res1r = df1.align(df2, join="left")
+        res2l, res2r = df2.align(df1, join="right")
+
+        expl = df1
+        tm.assert_frame_equal(expl, res1l)
+        tm.assert_frame_equal(expl, res2r)
+        expr = DataFrame([0, 0, 1, 1, np.nan, np.nan] * 2, index=midx)
+        tm.assert_frame_equal(expr, res1r)
+        tm.assert_frame_equal(expr, res2l)
+
+        res1l, res1r = df1.align(df2, join="right")
+        res2l, res2r = df2.align(df1, join="left")
+
+        exp_idx = pd.MultiIndex.from_product(
+            [range(2), range(2), range(2)], names=("a", "b", "c")
+        )
+        expl = DataFrame([0, 1, 2, 3, 6, 7, 8, 9], index=exp_idx)
+        tm.assert_frame_equal(expl, res1l)
+        tm.assert_frame_equal(expl, res2r)
+        expr = DataFrame([0, 0, 1, 1] * 2, index=exp_idx)
+        tm.assert_frame_equal(expr, res1r)
+        tm.assert_frame_equal(expr, res2l)
+
+    def test_align_series_combinations(self):
+        df = DataFrame({"a": [1, 3, 5], "b": [1, 3, 5]}, index=list("ACE"))
+        s = Series([1, 2, 4], index=list("ABD"), name="x")
+
+        # frame + series
+        res1, res2 = df.align(s, axis=0)
+        exp1 = DataFrame(
+            {"a": [1, np.nan, 3, np.nan, 5], "b": [1, np.nan, 3, np.nan, 5]},
+            index=list("ABCDE"),
+        )
+        exp2 = Series([1, 2, np.nan, 4, np.nan], index=list("ABCDE"), name="x")
+
+        tm.assert_frame_equal(res1, exp1)
+        tm.assert_series_equal(res2, exp2)
+
+        # series + frame
+        res1, res2 = s.align(df)
+        tm.assert_series_equal(res1, exp2)
+        tm.assert_frame_equal(res2, exp1)
+
+    def test_multiindex_align_to_series_with_common_index_level(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series([1, 2], index=bar_index, name="foo_series")
+        df = DataFrame(
+            {"col": np.arange(6)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_left(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series(
+            [1, 2, 3, 4], index=Index([1, 2, 3, 4], name="bar"), name="foo_series"
+        )
+        df = DataFrame(
+            {"col": np.arange(6)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_right(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2, 3, 4], name="bar")
+
+        series = Series([1, 2], index=Index([1, 2], name="bar"), name="foo_series")
+        df = DataFrame(
+            {"col": np.arange(12)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series(
+            [1, 2, np.nan, np.nan] * 3, index=df.index, name="foo_series"
+        )
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_both(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 3, 4], name="bar")
+
+        series = Series(
+            [1, 2, 3], index=Index([1, 2, 4], name="bar"), name="foo_series"
+        )
+        df = DataFrame(
+            {"col": np.arange(9)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, np.nan, 3] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_non_unique_cols(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series([1, 2], index=bar_index, name="foo_series")
+        df = DataFrame(
+            np.arange(18).reshape(6, 3),
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+        df.columns = ["cfoo", "cbar", "cfoo"]
+
+        expected = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_left, result_right = df.align(series, axis=0)
+
+        tm.assert_series_equal(result_right, expected)
+        tm.assert_index_equal(result_left.columns, df.columns)
+
+    def test_missing_axis_specification_exception(self):
+        df = DataFrame(np.arange(50).reshape((10, 5)))
+        series = Series(np.arange(5))
+
+        with pytest.raises(ValueError, match=r"axis=0 or 1"):
+            df.align(series)
+
+    def _check_align(self, a, b, axis, fill_axis, how, method, limit=None):
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            aa, ab = a.align(
+                b, axis=axis, join=how, method=method, limit=limit, fill_axis=fill_axis
+            )
+
+        join_index, join_columns = None, None
+
+        ea, eb = a, b
+        if axis is None or axis == 0:
+            join_index = a.index.join(b.index, how=how)
+            ea = ea.reindex(index=join_index)
+            eb = eb.reindex(index=join_index)
+
+        if axis is None or axis == 1:
+            join_columns = a.columns.join(b.columns, how=how)
+            ea = ea.reindex(columns=join_columns)
+            eb = eb.reindex(columns=join_columns)
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            ea = ea.fillna(axis=fill_axis, method=method, limit=limit)
+            eb = eb.fillna(axis=fill_axis, method=method, limit=limit)
+
+        tm.assert_frame_equal(aa, ea)
+        tm.assert_frame_equal(ab, eb)
+
+    @pytest.mark.parametrize("meth", ["pad", "bfill"])
+    @pytest.mark.parametrize("ax", [0, 1, None])
+    @pytest.mark.parametrize("fax", [0, 1])
+    @pytest.mark.parametrize("how", ["inner", "outer", "left", "right"])
+    def test_align_fill_method(self, how, meth, ax, fax, float_frame):
+        df = float_frame
+        self._check_align_fill(df, how, meth, ax, fax)
+
+    def _check_align_fill(self, frame, kind, meth, ax, fax):
+        left = frame.iloc[0:4, :10]
+        right = frame.iloc[2:, 6:]
+        empty = frame.iloc[:0, :0]
+
+        self._check_align(left, right, axis=ax, fill_axis=fax, how=kind, method=meth)
+        self._check_align(
+            left, right, axis=ax, fill_axis=fax, how=kind, method=meth, limit=1
+        )
+
+        # empty left
+        self._check_align(empty, right, axis=ax, fill_axis=fax, how=kind, method=meth)
+        self._check_align(
+            empty, right, axis=ax, fill_axis=fax, how=kind, method=meth, limit=1
+        )
+
+        # empty right
+        self._check_align(left, empty, axis=ax, fill_axis=fax, how=kind, method=meth)
+        self._check_align(
+            left, empty, axis=ax, fill_axis=fax, how=kind, method=meth, limit=1
+        )
+
+        # both empty
+        self._check_align(empty, empty, axis=ax, fill_axis=fax, how=kind, method=meth)
+        self._check_align(
+            empty, empty, axis=ax, fill_axis=fax, how=kind, method=meth, limit=1
+        )
+
+    def test_align_series_check_copy(self):
+        # GH#
+        df = DataFrame({0: [1, 2]})
+        ser = Series([1], name=0)
+        expected = ser.copy()
+        result, other = df.align(ser, axis=1)
+        ser.iloc[0] = 100
+        tm.assert_series_equal(other, expected)
+
+    def test_align_identical_different_object(self):
+        # GH#51032
+        df = DataFrame({"a": [1, 2]})
+        ser = Series([3, 4])
+        result, result2 = df.align(ser, axis=0)
+        tm.assert_frame_equal(result, df)
+        tm.assert_series_equal(result2, ser)
+        assert df is not result
+        assert ser is not result2
+
+    def test_align_identical_different_object_columns(self):
+        # GH#51032
+        df = DataFrame({"a": [1, 2]})
+        ser = Series([1], index=["a"])
+        result, result2 = df.align(ser, axis=1)
+        tm.assert_frame_equal(result, df)
+        tm.assert_series_equal(result2, ser)
+        assert df is not result
+        assert ser is not result2
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_asfreq.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_asfreq.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c5137db94c16fc24727b7c52f756a706dc25cc3
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_asfreq.py
@@ -0,0 +1,235 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.offsets import MonthEnd
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Series,
+    date_range,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+from pandas.tseries import offsets
+
+
+class TestAsFreq:
+    @pytest.fixture(params=["s", "ms", "us", "ns"])
+    def unit(self, request):
+        return request.param
+
+    def test_asfreq2(self, frame_or_series):
+        ts = frame_or_series(
+            [0.0, 1.0, 2.0],
+            index=DatetimeIndex(
+                [
+                    datetime(2009, 10, 30),
+                    datetime(2009, 11, 30),
+                    datetime(2009, 12, 31),
+                ],
+                freq="BM",
+            ),
+        )
+
+        daily_ts = ts.asfreq("B")
+        monthly_ts = daily_ts.asfreq("BM")
+        tm.assert_equal(monthly_ts, ts)
+
+        daily_ts = ts.asfreq("B", method="pad")
+        monthly_ts = daily_ts.asfreq("BM")
+        tm.assert_equal(monthly_ts, ts)
+
+        daily_ts = ts.asfreq(offsets.BDay())
+        monthly_ts = daily_ts.asfreq(offsets.BMonthEnd())
+        tm.assert_equal(monthly_ts, ts)
+
+        result = ts[:0].asfreq("M")
+        assert len(result) == 0
+        assert result is not ts
+
+        if frame_or_series is Series:
+            daily_ts = ts.asfreq("D", fill_value=-1)
+            result = daily_ts.value_counts().sort_index()
+            expected = Series(
+                [60, 1, 1, 1], index=[-1.0, 2.0, 1.0, 0.0], name="count"
+            ).sort_index()
+            tm.assert_series_equal(result, expected)
+
+    def test_asfreq_datetimeindex_empty(self, frame_or_series):
+        # GH#14320
+        index = DatetimeIndex(["2016-09-29 11:00"])
+        expected = frame_or_series(index=index, dtype=object).asfreq("H")
+        result = frame_or_series([3], index=index.copy()).asfreq("H")
+        tm.assert_index_equal(expected.index, result.index)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_tz_aware_asfreq_smoke(self, tz, frame_or_series):
+        dr = date_range("2011-12-01", "2012-07-20", freq="D", tz=tz)
+
+        obj = frame_or_series(
+            np.random.default_rng(2).standard_normal(len(dr)), index=dr
+        )
+
+        # it works!
+        obj.asfreq("T")
+
+    def test_asfreq_normalize(self, frame_or_series):
+        rng = date_range("1/1/2000 09:30", periods=20)
+        norm = date_range("1/1/2000", periods=20)
+
+        vals = np.random.default_rng(2).standard_normal((20, 3))
+
+        obj = DataFrame(vals, index=rng)
+        expected = DataFrame(vals, index=norm)
+        if frame_or_series is Series:
+            obj = obj[0]
+            expected = expected[0]
+
+        result = obj.asfreq("D", normalize=True)
+        tm.assert_equal(result, expected)
+
+    def test_asfreq_keep_index_name(self, frame_or_series):
+        # GH#9854
+        index_name = "bar"
+        index = date_range("20130101", periods=20, name=index_name)
+        obj = DataFrame(list(range(20)), columns=["foo"], index=index)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        assert index_name == obj.index.name
+        assert index_name == obj.asfreq("10D").index.name
+
+    def test_asfreq_ts(self, frame_or_series):
+        index = period_range(freq="A", start="1/1/2001", end="12/31/2010")
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), 3)), index=index
+        )
+        obj = tm.get_obj(obj, frame_or_series)
+
+        result = obj.asfreq("D", how="end")
+        exp_index = index.asfreq("D", how="end")
+        assert len(result) == len(obj)
+        tm.assert_index_equal(result.index, exp_index)
+
+        result = obj.asfreq("D", how="start")
+        exp_index = index.asfreq("D", how="start")
+        assert len(result) == len(obj)
+        tm.assert_index_equal(result.index, exp_index)
+
+    def test_asfreq_resample_set_correct_freq(self, frame_or_series):
+        # GH#5613
+        # we test if .asfreq() and .resample() set the correct value for .freq
+        dti = to_datetime(["2012-01-01", "2012-01-02", "2012-01-03"])
+        obj = DataFrame({"col": [1, 2, 3]}, index=dti)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        # testing the settings before calling .asfreq() and .resample()
+        assert obj.index.freq is None
+        assert obj.index.inferred_freq == "D"
+
+        # does .asfreq() set .freq correctly?
+        assert obj.asfreq("D").index.freq == "D"
+
+        # does .resample() set .freq correctly?
+        assert obj.resample("D").asfreq().index.freq == "D"
+
+    def test_asfreq_empty(self, datetime_frame):
+        # test does not blow up on length-0 DataFrame
+        zero_length = datetime_frame.reindex([])
+        result = zero_length.asfreq("BM")
+        assert result is not zero_length
+
+    def test_asfreq(self, datetime_frame):
+        offset_monthly = datetime_frame.asfreq(offsets.BMonthEnd())
+        rule_monthly = datetime_frame.asfreq("BM")
+
+        tm.assert_frame_equal(offset_monthly, rule_monthly)
+
+        rule_monthly.asfreq("B", method="pad")
+        # TODO: actually check that this worked.
+
+        # don't forget!
+        rule_monthly.asfreq("B", method="pad")
+
+    def test_asfreq_datetimeindex(self):
+        df = DataFrame(
+            {"A": [1, 2, 3]},
+            index=[datetime(2011, 11, 1), datetime(2011, 11, 2), datetime(2011, 11, 3)],
+        )
+        df = df.asfreq("B")
+        assert isinstance(df.index, DatetimeIndex)
+
+        ts = df["A"].asfreq("B")
+        assert isinstance(ts.index, DatetimeIndex)
+
+    def test_asfreq_fillvalue(self):
+        # test for fill value during upsampling, related to issue 3715
+
+        # setup
+        rng = date_range("1/1/2016", periods=10, freq="2S")
+        # Explicit cast to 'float' to avoid implicit cast when setting None
+        ts = Series(np.arange(len(rng)), index=rng, dtype="float")
+        df = DataFrame({"one": ts})
+
+        # insert pre-existing missing value
+        df.loc["2016-01-01 00:00:08", "one"] = None
+
+        actual_df = df.asfreq(freq="1S", fill_value=9.0)
+        expected_df = df.asfreq(freq="1S").fillna(9.0)
+        expected_df.loc["2016-01-01 00:00:08", "one"] = None
+        tm.assert_frame_equal(expected_df, actual_df)
+
+        expected_series = ts.asfreq(freq="1S").fillna(9.0)
+        actual_series = ts.asfreq(freq="1S", fill_value=9.0)
+        tm.assert_series_equal(expected_series, actual_series)
+
+    def test_asfreq_with_date_object_index(self, frame_or_series):
+        rng = date_range("1/1/2000", periods=20)
+        ts = frame_or_series(np.random.default_rng(2).standard_normal(20), index=rng)
+
+        ts2 = ts.copy()
+        ts2.index = [x.date() for x in ts2.index]
+
+        result = ts2.asfreq("4H", method="ffill")
+        expected = ts.asfreq("4H", method="ffill")
+        tm.assert_equal(result, expected)
+
+    def test_asfreq_with_unsorted_index(self, frame_or_series):
+        # GH#39805
+        # Test that rows are not dropped when the datetime index is out of order
+        index = to_datetime(["2021-01-04", "2021-01-02", "2021-01-03", "2021-01-01"])
+        result = frame_or_series(range(4), index=index)
+
+        expected = result.reindex(sorted(index))
+        expected.index = expected.index._with_freq("infer")
+
+        result = result.asfreq("D")
+        tm.assert_equal(result, expected)
+
+    def test_asfreq_after_normalize(self, unit):
+        # https://github.com/pandas-dev/pandas/issues/50727
+        result = DatetimeIndex(
+            date_range("2000", periods=2).as_unit(unit).normalize(), freq="D"
+        )
+        expected = DatetimeIndex(["2000-01-01", "2000-01-02"], freq="D").as_unit(unit)
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "freq, freq_half",
+        [
+            ("2M", "M"),
+            (MonthEnd(2), MonthEnd(1)),
+        ],
+    )
+    def test_asfreq_2M(self, freq, freq_half):
+        index = date_range("1/1/2000", periods=6, freq=freq_half)
+        df = DataFrame({"s": Series([0.0, 1.0, 2.0, 3.0, 4.0, 5.0], index=index)})
+        expected = df.asfreq(freq=freq)
+
+        index = date_range("1/1/2000", periods=3, freq=freq)
+        result = DataFrame({"s": Series([0.0, 2.0, 4.0], index=index)})
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_asof.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_asof.py
new file mode 100644
index 0000000000000000000000000000000000000000..5683ec60b0d88048f85589f5cfa760eb04183577
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_asof.py
@@ -0,0 +1,198 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import IncompatibleFrequency
+
+from pandas import (
+    DataFrame,
+    Period,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def date_range_frame():
+    """
+    Fixture for DataFrame of ints with date_range index
+
+    Columns are ['A', 'B'].
+    """
+    N = 50
+    rng = date_range("1/1/1990", periods=N, freq="53s")
+    return DataFrame({"A": np.arange(N), "B": np.arange(N)}, index=rng)
+
+
+class TestFrameAsof:
+    def test_basic(self, date_range_frame):
+        # Explicitly cast to float to avoid implicit cast when setting np.nan
+        df = date_range_frame.astype({"A": "float"})
+        N = 50
+        df.loc[df.index[15:30], "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = df.asof(dates)
+        assert result.notna().all(1).all()
+        lb = df.index[14]
+        ub = df.index[30]
+
+        dates = list(dates)
+
+        result = df.asof(dates)
+        assert result.notna().all(1).all()
+
+        mask = (result.index >= lb) & (result.index < ub)
+        rs = result[mask]
+        assert (rs == 14).all(1).all()
+
+    def test_subset(self, date_range_frame):
+        N = 10
+        # explicitly cast to float to avoid implicit upcast when setting to np.nan
+        df = date_range_frame.iloc[:N].copy().astype({"A": "float"})
+        df.loc[df.index[4:8], "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        # with a subset of A should be the same
+        result = df.asof(dates, subset="A")
+        expected = df.asof(dates)
+        tm.assert_frame_equal(result, expected)
+
+        # same with A/B
+        result = df.asof(dates, subset=["A", "B"])
+        expected = df.asof(dates)
+        tm.assert_frame_equal(result, expected)
+
+        # B gives df.asof
+        result = df.asof(dates, subset="B")
+        expected = df.resample("25s", closed="right").ffill().reindex(dates)
+        expected.iloc[20:] = 9
+        # no "missing", so "B" can retain int dtype (df["A"].dtype platform-dependent)
+        expected["B"] = expected["B"].astype(df["B"].dtype)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing(self, date_range_frame):
+        # GH 15118
+        # no match found - `where` value before earliest date in index
+        N = 10
+        # Cast to 'float64' to avoid upcast when introducing nan in df.asof
+        df = date_range_frame.iloc[:N].copy().astype("float64")
+
+        result = df.asof("1989-12-31")
+
+        expected = Series(
+            index=["A", "B"], name=Timestamp("1989-12-31"), dtype=np.float64
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = df.asof(to_datetime(["1989-12-31"]))
+        expected = DataFrame(
+            index=to_datetime(["1989-12-31"]), columns=["A", "B"], dtype="float64"
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # Check that we handle PeriodIndex correctly, dont end up with
+        #  period.ordinal for series name
+        df = df.to_period("D")
+        result = df.asof("1989-12-31")
+        assert isinstance(result.name, Period)
+
+    def test_asof_all_nans(self, frame_or_series):
+        # GH 15713
+        # DataFrame/Series is all nans
+        result = frame_or_series([np.nan]).asof([0])
+        expected = frame_or_series([np.nan])
+        tm.assert_equal(result, expected)
+
+    def test_all_nans(self, date_range_frame):
+        # GH 15713
+        # DataFrame is all nans
+
+        # testing non-default indexes, multiple inputs
+        N = 150
+        rng = date_range_frame.index
+        dates = date_range("1/1/1990", periods=N, freq="25s")
+        result = DataFrame(np.nan, index=rng, columns=["A"]).asof(dates)
+        expected = DataFrame(np.nan, index=dates, columns=["A"])
+        tm.assert_frame_equal(result, expected)
+
+        # testing multiple columns
+        dates = date_range("1/1/1990", periods=N, freq="25s")
+        result = DataFrame(np.nan, index=rng, columns=["A", "B", "C"]).asof(dates)
+        expected = DataFrame(np.nan, index=dates, columns=["A", "B", "C"])
+        tm.assert_frame_equal(result, expected)
+
+        # testing scalar input
+        result = DataFrame(np.nan, index=[1, 2], columns=["A", "B"]).asof([3])
+        expected = DataFrame(np.nan, index=[3], columns=["A", "B"])
+        tm.assert_frame_equal(result, expected)
+
+        result = DataFrame(np.nan, index=[1, 2], columns=["A", "B"]).asof(3)
+        expected = Series(np.nan, index=["A", "B"], name=3)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "stamp,expected",
+        [
+            (
+                Timestamp("2018-01-01 23:22:43.325+00:00"),
+                Series(2, name=Timestamp("2018-01-01 23:22:43.325+00:00")),
+            ),
+            (
+                Timestamp("2018-01-01 22:33:20.682+01:00"),
+                Series(1, name=Timestamp("2018-01-01 22:33:20.682+01:00")),
+            ),
+        ],
+    )
+    def test_time_zone_aware_index(self, stamp, expected):
+        # GH21194
+        # Testing awareness of DataFrame index considering different
+        # UTC and timezone
+        df = DataFrame(
+            data=[1, 2],
+            index=[
+                Timestamp("2018-01-01 21:00:05.001+00:00"),
+                Timestamp("2018-01-01 22:35:10.550+00:00"),
+            ],
+        )
+
+        result = df.asof(stamp)
+        tm.assert_series_equal(result, expected)
+
+    def test_is_copy(self, date_range_frame):
+        # GH-27357, GH-30784: ensure the result of asof is an actual copy and
+        # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+        df = date_range_frame.astype({"A": "float"})
+        N = 50
+        df.loc[df.index[15:30], "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = df.asof(dates)
+
+        with tm.assert_produces_warning(None):
+            result["C"] = 1
+
+    def test_asof_periodindex_mismatched_freq(self):
+        N = 50
+        rng = period_range("1/1/1990", periods=N, freq="H")
+        df = DataFrame(np.random.default_rng(2).standard_normal(N), index=rng)
+
+        # Mismatched freq
+        msg = "Input has different freq"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            df.asof(rng.asfreq("D"))
+
+    def test_asof_preserves_bool_dtype(self):
+        # GH#16063 was casting bools to floats
+        dti = date_range("2017-01-01", freq="MS", periods=4)
+        ser = Series([True, False, True], index=dti[:-1])
+
+        ts = dti[-1]
+        res = ser.asof([ts])
+
+        expected = Series([True], index=[ts])
+        tm.assert_series_equal(res, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_assign.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_assign.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ae501d43e74252a420acf96b9428ab4b8f5f211
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_assign.py
@@ -0,0 +1,84 @@
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestAssign:
+    def test_assign(self):
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        original = df.copy()
+        result = df.assign(C=df.B / df.A)
+        expected = df.copy()
+        expected["C"] = [4, 2.5, 2]
+        tm.assert_frame_equal(result, expected)
+
+        # lambda syntax
+        result = df.assign(C=lambda x: x.B / x.A)
+        tm.assert_frame_equal(result, expected)
+
+        # original is unmodified
+        tm.assert_frame_equal(df, original)
+
+        # Non-Series array-like
+        result = df.assign(C=[4, 2.5, 2])
+        tm.assert_frame_equal(result, expected)
+        # original is unmodified
+        tm.assert_frame_equal(df, original)
+
+        result = df.assign(B=df.B / df.A)
+        expected = expected.drop("B", axis=1).rename(columns={"C": "B"})
+        tm.assert_frame_equal(result, expected)
+
+        # overwrite
+        result = df.assign(A=df.A + df.B)
+        expected = df.copy()
+        expected["A"] = [5, 7, 9]
+        tm.assert_frame_equal(result, expected)
+
+        # lambda
+        result = df.assign(A=lambda x: x.A + x.B)
+        tm.assert_frame_equal(result, expected)
+
+    def test_assign_multiple(self):
+        df = DataFrame([[1, 4], [2, 5], [3, 6]], columns=["A", "B"])
+        result = df.assign(C=[7, 8, 9], D=df.A, E=lambda x: x.B)
+        expected = DataFrame(
+            [[1, 4, 7, 1, 4], [2, 5, 8, 2, 5], [3, 6, 9, 3, 6]], columns=list("ABCDE")
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_assign_order(self):
+        # GH 9818
+        df = DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
+        result = df.assign(D=df.A + df.B, C=df.A - df.B)
+
+        expected = DataFrame([[1, 2, 3, -1], [3, 4, 7, -1]], columns=list("ABDC"))
+        tm.assert_frame_equal(result, expected)
+        result = df.assign(C=df.A - df.B, D=df.A + df.B)
+
+        expected = DataFrame([[1, 2, -1, 3], [3, 4, -1, 7]], columns=list("ABCD"))
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_assign_bad(self):
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+
+        # non-keyword argument
+        msg = r"assign\(\) takes 1 positional argument but 2 were given"
+        with pytest.raises(TypeError, match=msg):
+            df.assign(lambda x: x.A)
+        msg = "'DataFrame' object has no attribute 'C'"
+        with pytest.raises(AttributeError, match=msg):
+            df.assign(C=df.A, D=df.A + df.C)
+
+    def test_assign_dependent(self):
+        df = DataFrame({"A": [1, 2], "B": [3, 4]})
+
+        result = df.assign(C=df.A, D=lambda x: x["A"] + x["C"])
+        expected = DataFrame([[1, 3, 1, 2], [2, 4, 2, 4]], columns=list("ABCD"))
+        tm.assert_frame_equal(result, expected)
+
+        result = df.assign(C=lambda df: df.A, D=lambda df: df["A"] + df["C"])
+        expected = DataFrame([[1, 3, 1, 2], [2, 4, 2, 4]], columns=list("ABCD"))
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_astype.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..6590f10c6b9670cbd3cabbd9dba88f6bdd7e7a68
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_astype.py
@@ -0,0 +1,889 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.compat import pa_version_under7p0
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalDtype,
+    DataFrame,
+    DatetimeTZDtype,
+    Index,
+    Interval,
+    IntervalDtype,
+    NaT,
+    Series,
+    Timedelta,
+    Timestamp,
+    concat,
+    date_range,
+    option_context,
+)
+import pandas._testing as tm
+
+
+def _check_cast(df, v):
+    """
+    Check if all dtypes of df are equal to v
+    """
+    assert all(s.dtype.name == v for _, s in df.items())
+
+
+class TestAstype:
+    def test_astype_float(self, float_frame):
+        casted = float_frame.astype(int)
+        expected = DataFrame(
+            float_frame.values.astype(int),
+            index=float_frame.index,
+            columns=float_frame.columns,
+        )
+        tm.assert_frame_equal(casted, expected)
+
+        casted = float_frame.astype(np.int32)
+        expected = DataFrame(
+            float_frame.values.astype(np.int32),
+            index=float_frame.index,
+            columns=float_frame.columns,
+        )
+        tm.assert_frame_equal(casted, expected)
+
+        float_frame["foo"] = "5"
+        casted = float_frame.astype(int)
+        expected = DataFrame(
+            float_frame.values.astype(int),
+            index=float_frame.index,
+            columns=float_frame.columns,
+        )
+        tm.assert_frame_equal(casted, expected)
+
+    def test_astype_mixed_float(self, mixed_float_frame):
+        # mixed casting
+        casted = mixed_float_frame.reindex(columns=["A", "B"]).astype("float32")
+        _check_cast(casted, "float32")
+
+        casted = mixed_float_frame.reindex(columns=["A", "B"]).astype("float16")
+        _check_cast(casted, "float16")
+
+    def test_astype_mixed_type(self, mixed_type_frame):
+        # mixed casting
+        mn = mixed_type_frame._get_numeric_data().copy()
+        mn["little_float"] = np.array(12345.0, dtype="float16")
+        mn["big_float"] = np.array(123456789101112.0, dtype="float64")
+
+        casted = mn.astype("float64")
+        _check_cast(casted, "float64")
+
+        casted = mn.astype("int64")
+        _check_cast(casted, "int64")
+
+        casted = mn.reindex(columns=["little_float"]).astype("float16")
+        _check_cast(casted, "float16")
+
+        casted = mn.astype("float32")
+        _check_cast(casted, "float32")
+
+        casted = mn.astype("int32")
+        _check_cast(casted, "int32")
+
+        # to object
+        casted = mn.astype("O")
+        _check_cast(casted, "object")
+
+    def test_astype_with_exclude_string(self, float_frame):
+        df = float_frame.copy()
+        expected = float_frame.astype(int)
+        df["string"] = "foo"
+        casted = df.astype(int, errors="ignore")
+
+        expected["string"] = "foo"
+        tm.assert_frame_equal(casted, expected)
+
+        df = float_frame.copy()
+        expected = float_frame.astype(np.int32)
+        df["string"] = "foo"
+        casted = df.astype(np.int32, errors="ignore")
+
+        expected["string"] = "foo"
+        tm.assert_frame_equal(casted, expected)
+
+    def test_astype_with_view_float(self, float_frame):
+        # this is the only real reason to do it this way
+        tf = np.round(float_frame).astype(np.int32)
+        tf.astype(np.float32, copy=False)
+
+        # TODO(wesm): verification?
+        tf = float_frame.astype(np.float64)
+        tf.astype(np.int64, copy=False)
+
+    def test_astype_with_view_mixed_float(self, mixed_float_frame):
+        tf = mixed_float_frame.reindex(columns=["A", "B", "C"])
+
+        tf.astype(np.int64)
+        tf.astype(np.float32)
+
+    @pytest.mark.parametrize("dtype", [np.int32, np.int64])
+    @pytest.mark.parametrize("val", [np.nan, np.inf])
+    def test_astype_cast_nan_inf_int(self, val, dtype):
+        # see GH#14265
+        #
+        # Check NaN and inf --> raise error when converting to int.
+        msg = "Cannot convert non-finite values \\(NA or inf\\) to integer"
+        df = DataFrame([val])
+
+        with pytest.raises(ValueError, match=msg):
+            df.astype(dtype)
+
+    def test_astype_str(self):
+        # see GH#9757
+        a = Series(date_range("2010-01-04", periods=5))
+        b = Series(date_range("3/6/2012 00:00", periods=5, tz="US/Eastern"))
+        c = Series([Timedelta(x, unit="d") for x in range(5)])
+        d = Series(range(5))
+        e = Series([0.0, 0.2, 0.4, 0.6, 0.8])
+
+        df = DataFrame({"a": a, "b": b, "c": c, "d": d, "e": e})
+
+        # Datetime-like
+        result = df.astype(str)
+
+        expected = DataFrame(
+            {
+                "a": list(map(str, (Timestamp(x)._date_repr for x in a._values))),
+                "b": list(map(str, map(Timestamp, b._values))),
+                "c": [Timedelta(x)._repr_base() for x in c._values],
+                "d": list(map(str, d._values)),
+                "e": list(map(str, e._values)),
+            }
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_str_float(self):
+        # see GH#11302
+        result = DataFrame([np.nan]).astype(str)
+        expected = DataFrame(["nan"])
+
+        tm.assert_frame_equal(result, expected)
+        result = DataFrame([1.12345678901234567890]).astype(str)
+
+        val = "1.1234567890123457"
+        expected = DataFrame([val])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype_class", [dict, Series])
+    def test_astype_dict_like(self, dtype_class):
+        # GH7271 & GH16717
+        a = Series(date_range("2010-01-04", periods=5))
+        b = Series(range(5))
+        c = Series([0.0, 0.2, 0.4, 0.6, 0.8])
+        d = Series(["1.0", "2", "3.14", "4", "5.4"])
+        df = DataFrame({"a": a, "b": b, "c": c, "d": d})
+        original = df.copy(deep=True)
+
+        # change type of a subset of columns
+        dt1 = dtype_class({"b": "str", "d": "float32"})
+        result = df.astype(dt1)
+        expected = DataFrame(
+            {
+                "a": a,
+                "b": Series(["0", "1", "2", "3", "4"]),
+                "c": c,
+                "d": Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype="float32"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, original)
+
+        dt2 = dtype_class({"b": np.float32, "c": "float32", "d": np.float64})
+        result = df.astype(dt2)
+        expected = DataFrame(
+            {
+                "a": a,
+                "b": Series([0.0, 1.0, 2.0, 3.0, 4.0], dtype="float32"),
+                "c": Series([0.0, 0.2, 0.4, 0.6, 0.8], dtype="float32"),
+                "d": Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype="float64"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, original)
+
+        # change all columns
+        dt3 = dtype_class({"a": str, "b": str, "c": str, "d": str})
+        tm.assert_frame_equal(df.astype(dt3), df.astype(str))
+        tm.assert_frame_equal(df, original)
+
+        # error should be raised when using something other than column labels
+        # in the keys of the dtype dict
+        dt4 = dtype_class({"b": str, 2: str})
+        dt5 = dtype_class({"e": str})
+        msg_frame = (
+            "Only a column name can be used for the key in a dtype mappings argument. "
+            "'{}' not found in columns."
+        )
+        with pytest.raises(KeyError, match=msg_frame.format(2)):
+            df.astype(dt4)
+        with pytest.raises(KeyError, match=msg_frame.format("e")):
+            df.astype(dt5)
+        tm.assert_frame_equal(df, original)
+
+        # if the dtypes provided are the same as the original dtypes, the
+        # resulting DataFrame should be the same as the original DataFrame
+        dt6 = dtype_class({col: df[col].dtype for col in df.columns})
+        equiv = df.astype(dt6)
+        tm.assert_frame_equal(df, equiv)
+        tm.assert_frame_equal(df, original)
+
+        # GH#16717
+        # if dtypes provided is empty, the resulting DataFrame
+        # should be the same as the original DataFrame
+        dt7 = dtype_class({}) if dtype_class is dict else dtype_class({}, dtype=object)
+        equiv = df.astype(dt7)
+        tm.assert_frame_equal(df, equiv)
+        tm.assert_frame_equal(df, original)
+
+    def test_astype_duplicate_col(self):
+        a1 = Series([1, 2, 3, 4, 5], name="a")
+        b = Series([0.1, 0.2, 0.4, 0.6, 0.8], name="b")
+        a2 = Series([0, 1, 2, 3, 4], name="a")
+        df = concat([a1, b, a2], axis=1)
+
+        result = df.astype(str)
+        a1_str = Series(["1", "2", "3", "4", "5"], dtype="str", name="a")
+        b_str = Series(["0.1", "0.2", "0.4", "0.6", "0.8"], dtype=str, name="b")
+        a2_str = Series(["0", "1", "2", "3", "4"], dtype="str", name="a")
+        expected = concat([a1_str, b_str, a2_str], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.astype({"a": "str"})
+        expected = concat([a1_str, b, a2_str], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_duplicate_col_series_arg(self):
+        # GH#44417
+        vals = np.random.default_rng(2).standard_normal((3, 4))
+        df = DataFrame(vals, columns=["A", "B", "C", "A"])
+        dtypes = df.dtypes
+        dtypes.iloc[0] = str
+        dtypes.iloc[2] = "Float64"
+
+        result = df.astype(dtypes)
+        expected = DataFrame(
+            {
+                0: vals[:, 0].astype(str),
+                1: vals[:, 1],
+                2: pd.array(vals[:, 2], dtype="Float64"),
+                3: vals[:, 3],
+            }
+        )
+        expected.columns = df.columns
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "category",
+            CategoricalDtype(),
+            CategoricalDtype(ordered=True),
+            CategoricalDtype(ordered=False),
+            CategoricalDtype(categories=list("abcdef")),
+            CategoricalDtype(categories=list("edba"), ordered=False),
+            CategoricalDtype(categories=list("edcb"), ordered=True),
+        ],
+        ids=repr,
+    )
+    def test_astype_categorical(self, dtype):
+        # GH#18099
+        d = {"A": list("abbc"), "B": list("bccd"), "C": list("cdde")}
+        df = DataFrame(d)
+        result = df.astype(dtype)
+        expected = DataFrame({k: Categorical(v, dtype=dtype) for k, v in d.items()})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("cls", [CategoricalDtype, DatetimeTZDtype, IntervalDtype])
+    def test_astype_categoricaldtype_class_raises(self, cls):
+        df = DataFrame({"A": ["a", "a", "b", "c"]})
+        xpr = f"Expected an instance of {cls.__name__}"
+        with pytest.raises(TypeError, match=xpr):
+            df.astype({"A": cls})
+
+        with pytest.raises(TypeError, match=xpr):
+            df["A"].astype(cls)
+
+    @pytest.mark.parametrize("dtype", ["Int64", "Int32", "Int16"])
+    def test_astype_extension_dtypes(self, dtype):
+        # GH#22578
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], columns=["a", "b"])
+
+        expected1 = DataFrame(
+            {
+                "a": pd.array([1, 3, 5], dtype=dtype),
+                "b": pd.array([2, 4, 6], dtype=dtype),
+            }
+        )
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype(dtype).astype("float64"), df)
+
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], columns=["a", "b"])
+        df["b"] = df["b"].astype(dtype)
+        expected2 = DataFrame(
+            {"a": [1.0, 3.0, 5.0], "b": pd.array([2, 4, 6], dtype=dtype)}
+        )
+        tm.assert_frame_equal(df, expected2)
+
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+
+    @pytest.mark.parametrize("dtype", ["Int64", "Int32", "Int16"])
+    def test_astype_extension_dtypes_1d(self, dtype):
+        # GH#22578
+        df = DataFrame({"a": [1.0, 2.0, 3.0]})
+
+        expected1 = DataFrame({"a": pd.array([1, 2, 3], dtype=dtype)})
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+
+        df = DataFrame({"a": [1.0, 2.0, 3.0]})
+        df["a"] = df["a"].astype(dtype)
+        expected2 = DataFrame({"a": pd.array([1, 2, 3], dtype=dtype)})
+        tm.assert_frame_equal(df, expected2)
+
+        tm.assert_frame_equal(df.astype(dtype), expected1)
+        tm.assert_frame_equal(df.astype("int64").astype(dtype), expected1)
+
+    @pytest.mark.parametrize("dtype", ["category", "Int64"])
+    def test_astype_extension_dtypes_duplicate_col(self, dtype):
+        # GH#24704
+        a1 = Series([0, np.nan, 4], name="a")
+        a2 = Series([np.nan, 3, 5], name="a")
+        df = concat([a1, a2], axis=1)
+
+        result = df.astype(dtype)
+        expected = concat([a1.astype(dtype), a2.astype(dtype)], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype", [{100: "float64", 200: "uint64"}, "category", "float64"]
+    )
+    def test_astype_column_metadata(self, dtype):
+        # GH#19920
+        columns = Index([100, 200, 300], dtype=np.uint64, name="foo")
+        df = DataFrame(np.arange(15).reshape(5, 3), columns=columns)
+        df = df.astype(dtype)
+        tm.assert_index_equal(df.columns, columns)
+
+    @pytest.mark.parametrize("unit", ["Y", "M", "W", "D", "h", "m"])
+    def test_astype_from_object_to_datetime_unit(self, unit):
+        vals = [
+            ["2015-01-01", "2015-01-02", "2015-01-03"],
+            ["2017-01-01", "2017-01-02", "2017-02-03"],
+        ]
+        df = DataFrame(vals, dtype=object)
+        with pytest.raises(TypeError, match="Cannot cast"):
+            df.astype(f"M8[{unit}]")
+
+    @pytest.mark.parametrize("unit", ["Y", "M", "W", "D", "h", "m"])
+    def test_astype_from_object_to_timedelta_unit(self, unit):
+        vals = [
+            ["1 Day", "2 Days", "3 Days"],
+            ["4 Days", "5 Days", "6 Days"],
+        ]
+        df = DataFrame(vals, dtype=object)
+        msg = (
+            r"Cannot convert from timedelta64\[ns\] to timedelta64\[.*\]. "
+            "Supported resolutions are 's', 'ms', 'us', 'ns'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            # TODO: this is ValueError while for DatetimeArray it is TypeError;
+            #  get these consistent
+            df.astype(f"m8[{unit}]")
+
+    @pytest.mark.parametrize("dtype", ["M8", "m8"])
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_from_datetimelike_to_object(self, dtype, unit):
+        # tests astype to object dtype
+        # GH#19223 / GH#12425
+        dtype = f"{dtype}[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        result = df.astype(object)
+        assert (result.dtypes == object).all()
+
+        if dtype.startswith("M8"):
+            assert result.iloc[0, 0] == Timestamp(1, unit=unit)
+        else:
+            assert result.iloc[0, 0] == Timedelta(1, unit=unit)
+
+    @pytest.mark.parametrize("arr_dtype", [np.int64, np.float64])
+    @pytest.mark.parametrize("dtype", ["M8", "m8"])
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_datetimelike_unit(self, arr_dtype, dtype, unit):
+        # tests all units from numeric origination
+        # GH#19223 / GH#12425
+        dtype = f"{dtype}[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=arr_dtype)
+        df = DataFrame(arr)
+        result = df.astype(dtype)
+        expected = DataFrame(arr.astype(dtype))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_datetime_unit(self, unit):
+        # tests all units from datetime origination
+        # GH#19223
+        dtype = f"M8[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        ser = df.iloc[:, 0]
+        idx = Index(ser)
+        dta = ser._values
+
+        if unit in ["ns", "us", "ms", "s"]:
+            # GH#48928
+            result = df.astype(dtype)
+        else:
+            # we use the nearest supported dtype (i.e. M8[s])
+            msg = rf"Cannot cast DatetimeArray to dtype datetime64\[{unit}\]"
+            with pytest.raises(TypeError, match=msg):
+                df.astype(dtype)
+
+            with pytest.raises(TypeError, match=msg):
+                ser.astype(dtype)
+
+            with pytest.raises(TypeError, match=msg.replace("Array", "Index")):
+                idx.astype(dtype)
+
+            with pytest.raises(TypeError, match=msg):
+                dta.astype(dtype)
+
+            return
+
+        exp_df = DataFrame(arr.astype(dtype))
+        assert (exp_df.dtypes == dtype).all()
+        tm.assert_frame_equal(result, exp_df)
+
+        res_ser = ser.astype(dtype)
+        exp_ser = exp_df.iloc[:, 0]
+        assert exp_ser.dtype == dtype
+        tm.assert_series_equal(res_ser, exp_ser)
+
+        exp_dta = exp_ser._values
+
+        res_index = idx.astype(dtype)
+        exp_index = Index(exp_ser)
+        assert exp_index.dtype == dtype
+        tm.assert_index_equal(res_index, exp_index)
+
+        res_dta = dta.astype(dtype)
+        assert exp_dta.dtype == dtype
+        tm.assert_extension_array_equal(res_dta, exp_dta)
+
+    @pytest.mark.parametrize("unit", ["ns"])
+    def test_astype_to_timedelta_unit_ns(self, unit):
+        # preserver the timedelta conversion
+        # GH#19223
+        dtype = f"m8[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        result = df.astype(dtype)
+        expected = DataFrame(arr.astype(dtype))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_timedelta_unit(self, unit):
+        # coerce to float
+        # GH#19223 until 2.0 used to coerce to float
+        dtype = f"m8[{unit}]"
+        arr = np.array([[1, 2, 3]], dtype=dtype)
+        df = DataFrame(arr)
+        ser = df.iloc[:, 0]
+        tdi = Index(ser)
+        tda = tdi._values
+
+        if unit in ["us", "ms", "s"]:
+            assert (df.dtypes == dtype).all()
+            result = df.astype(dtype)
+        else:
+            # We get the nearest supported unit, i.e. "s"
+            assert (df.dtypes == "m8[s]").all()
+
+            msg = (
+                rf"Cannot convert from timedelta64\[s\] to timedelta64\[{unit}\]. "
+                "Supported resolutions are 's', 'ms', 'us', 'ns'"
+            )
+            with pytest.raises(ValueError, match=msg):
+                df.astype(dtype)
+            with pytest.raises(ValueError, match=msg):
+                ser.astype(dtype)
+            with pytest.raises(ValueError, match=msg):
+                tdi.astype(dtype)
+            with pytest.raises(ValueError, match=msg):
+                tda.astype(dtype)
+
+            return
+
+        result = df.astype(dtype)
+        # The conversion is a no-op, so we just get a copy
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
+    def test_astype_to_incorrect_datetimelike(self, unit):
+        # trying to astype a m to a M, or vice-versa
+        # GH#19224
+        dtype = f"M8[{unit}]"
+        other = f"m8[{unit}]"
+
+        df = DataFrame(np.array([[1, 2, 3]], dtype=dtype))
+        msg = "|".join(
+            [
+                # BlockManager path
+                rf"Cannot cast DatetimeArray to dtype timedelta64\[{unit}\]",
+                # ArrayManager path
+                "cannot astype a datetimelike from "
+                rf"\[datetime64\[ns\]\] to \[timedelta64\[{unit}\]\]",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.astype(other)
+
+        msg = "|".join(
+            [
+                # BlockManager path
+                rf"Cannot cast TimedeltaArray to dtype datetime64\[{unit}\]",
+                # ArrayManager path
+                "cannot astype a timedelta from "
+                rf"\[timedelta64\[ns\]\] to \[datetime64\[{unit}\]\]",
+            ]
+        )
+        df = DataFrame(np.array([[1, 2, 3]], dtype=other))
+        with pytest.raises(TypeError, match=msg):
+            df.astype(dtype)
+
+    def test_astype_arg_for_errors(self):
+        # GH#14878
+
+        df = DataFrame([1, 2, 3])
+
+        msg = (
+            "Expected value of kwarg 'errors' to be one of "
+            "['raise', 'ignore']. Supplied value is 'True'"
+        )
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            df.astype(np.float64, errors=True)
+
+        df.astype(np.int8, errors="ignore")
+
+    def test_astype_invalid_conversion(self):
+        # GH#47571
+        df = DataFrame({"a": [1, 2, "text"], "b": [1, 2, 3]})
+
+        msg = (
+            "invalid literal for int() with base 10: 'text': "
+            "Error while type casting for column 'a'"
+        )
+
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            df.astype({"a": int})
+
+    def test_astype_arg_for_errors_dictlist(self):
+        # GH#25905
+        df = DataFrame(
+            [
+                {"a": "1", "b": "16.5%", "c": "test"},
+                {"a": "2.2", "b": "15.3", "c": "another_test"},
+            ]
+        )
+        expected = DataFrame(
+            [
+                {"a": 1.0, "b": "16.5%", "c": "test"},
+                {"a": 2.2, "b": "15.3", "c": "another_test"},
+            ]
+        )
+        type_dict = {"a": "float64", "b": "float64", "c": "object"}
+
+        result = df.astype(dtype=type_dict, errors="ignore")
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_dt64tz(self, timezone_frame):
+        # astype
+        expected = np.array(
+            [
+                [
+                    Timestamp("2013-01-01 00:00:00"),
+                    Timestamp("2013-01-02 00:00:00"),
+                    Timestamp("2013-01-03 00:00:00"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
+                ],
+            ],
+            dtype=object,
+        ).T
+        expected = DataFrame(
+            expected,
+            index=timezone_frame.index,
+            columns=timezone_frame.columns,
+            dtype=object,
+        )
+        result = timezone_frame.astype(object)
+        tm.assert_frame_equal(result, expected)
+
+        msg = "Cannot use .astype to convert from timezone-aware dtype to timezone-"
+        with pytest.raises(TypeError, match=msg):
+            # dt64tz->dt64 deprecated
+            timezone_frame.astype("datetime64[ns]")
+
+    def test_astype_dt64tz_to_str(self, timezone_frame):
+        # str formatting
+        result = timezone_frame.astype(str)
+        expected = DataFrame(
+            [
+                [
+                    "2013-01-01",
+                    "2013-01-01 00:00:00-05:00",
+                    "2013-01-01 00:00:00+01:00",
+                ],
+                ["2013-01-02", "NaT", "NaT"],
+                [
+                    "2013-01-03",
+                    "2013-01-03 00:00:00-05:00",
+                    "2013-01-03 00:00:00+01:00",
+                ],
+            ],
+            columns=timezone_frame.columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+        with option_context("display.max_columns", 20):
+            result = str(timezone_frame)
+            assert (
+                "0 2013-01-01 2013-01-01 00:00:00-05:00 2013-01-01 00:00:00+01:00"
+            ) in result
+            assert (
+                "1 2013-01-02                       NaT                       NaT"
+            ) in result
+            assert (
+                "2 2013-01-03 2013-01-03 00:00:00-05:00 2013-01-03 00:00:00+01:00"
+            ) in result
+
+    def test_astype_empty_dtype_dict(self):
+        # issue mentioned further down in the following issue's thread
+        # https://github.com/pandas-dev/pandas/issues/33113
+        df = DataFrame()
+        result = df.astype({})
+        tm.assert_frame_equal(result, df)
+        assert result is not df
+
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            (["x", "y", "z"], "string[python]"),
+            pytest.param(
+                ["x", "y", "z"],
+                "string[pyarrow]",
+                marks=td.skip_if_no("pyarrow"),
+            ),
+            (["x", "y", "z"], "category"),
+            (3 * [Timestamp("2020-01-01", tz="UTC")], None),
+            (3 * [Interval(0, 1)], None),
+        ],
+    )
+    @pytest.mark.parametrize("errors", ["raise", "ignore"])
+    def test_astype_ignores_errors_for_extension_dtypes(self, data, dtype, errors):
+        # https://github.com/pandas-dev/pandas/issues/35471
+        df = DataFrame(Series(data, dtype=dtype))
+        if errors == "ignore":
+            expected = df
+            result = df.astype(float, errors=errors)
+            tm.assert_frame_equal(result, expected)
+        else:
+            msg = "(Cannot cast)|(could not convert)"
+            with pytest.raises((ValueError, TypeError), match=msg):
+                df.astype(float, errors=errors)
+
+    def test_astype_tz_conversion(self):
+        # GH 35973
+        val = {"tz": date_range("2020-08-30", freq="d", periods=2, tz="Europe/London")}
+        df = DataFrame(val)
+        result = df.astype({"tz": "datetime64[ns, Europe/Berlin]"})
+
+        expected = df
+        expected["tz"] = expected["tz"].dt.tz_convert("Europe/Berlin")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["UTC", "Europe/Berlin"])
+    def test_astype_tz_object_conversion(self, tz):
+        # GH 35973
+        val = {"tz": date_range("2020-08-30", freq="d", periods=2, tz="Europe/London")}
+        expected = DataFrame(val)
+
+        # convert expected to object dtype from other tz str (independently tested)
+        result = expected.astype({"tz": f"datetime64[ns, {tz}]"})
+        result = result.astype({"tz": "object"})
+
+        # do real test: object dtype to a specified tz, different from construction tz.
+        result = result.astype({"tz": "datetime64[ns, Europe/London]"})
+        tm.assert_frame_equal(result, expected)
+
+    def test_astype_dt64_to_string(self, frame_or_series, tz_naive_fixture):
+        # GH#41409
+        tz = tz_naive_fixture
+
+        dti = date_range("2016-01-01", periods=3, tz=tz)
+        dta = dti._data
+        dta[0] = NaT
+
+        obj = frame_or_series(dta)
+        result = obj.astype("string")
+
+        # Check that Series/DataFrame.astype matches DatetimeArray.astype
+        expected = frame_or_series(dta.astype("string"))
+        tm.assert_equal(result, expected)
+
+        item = result.iloc[0]
+        if frame_or_series is DataFrame:
+            item = item.iloc[0]
+        assert item is pd.NA
+
+        # For non-NA values, we should match what we get for non-EA str
+        alt = obj.astype(str)
+        assert np.all(alt.iloc[1:] == result.iloc[1:])
+
+    def test_astype_td64_to_string(self, frame_or_series):
+        # GH#41409
+        tdi = pd.timedelta_range("1 Day", periods=3)
+        obj = frame_or_series(tdi)
+
+        expected = frame_or_series(["1 days", "2 days", "3 days"], dtype="string")
+        result = obj.astype("string")
+        tm.assert_equal(result, expected)
+
+    def test_astype_bytes(self):
+        # GH#39474
+        result = DataFrame(["foo", "bar", "baz"]).astype(bytes)
+        assert result.dtypes[0] == np.dtype("S3")
+
+    @pytest.mark.parametrize(
+        "index_slice",
+        [
+            np.s_[:2, :2],
+            np.s_[:1, :2],
+            np.s_[:2, :1],
+            np.s_[::2, ::2],
+            np.s_[::1, ::2],
+            np.s_[::2, ::1],
+        ],
+    )
+    def test_astype_noncontiguous(self, index_slice):
+        # GH#42396
+        data = np.arange(16).reshape(4, 4)
+        df = DataFrame(data)
+
+        result = df.iloc[index_slice].astype("int16")
+        expected = df.iloc[index_slice]
+        tm.assert_frame_equal(result, expected, check_dtype=False)
+
+    def test_astype_retain_attrs(self, any_numpy_dtype):
+        # GH#44414
+        df = DataFrame({"a": [0, 1, 2], "b": [3, 4, 5]})
+        df.attrs["Location"] = "Michigan"
+
+        result = df.astype({"a": any_numpy_dtype}).attrs
+        expected = df.attrs
+
+        tm.assert_dict_equal(expected, result)
+
+
+class TestAstypeCategorical:
+    def test_astype_from_categorical3(self):
+        df = DataFrame({"cats": [1, 2, 3, 4, 5, 6], "vals": [1, 2, 3, 4, 5, 6]})
+        cats = Categorical([1, 2, 3, 4, 5, 6])
+        exp_df = DataFrame({"cats": cats, "vals": [1, 2, 3, 4, 5, 6]})
+        df["cats"] = df["cats"].astype("category")
+        tm.assert_frame_equal(exp_df, df)
+
+    def test_astype_from_categorical4(self):
+        df = DataFrame(
+            {"cats": ["a", "b", "b", "a", "a", "d"], "vals": [1, 2, 3, 4, 5, 6]}
+        )
+        cats = Categorical(["a", "b", "b", "a", "a", "d"])
+        exp_df = DataFrame({"cats": cats, "vals": [1, 2, 3, 4, 5, 6]})
+        df["cats"] = df["cats"].astype("category")
+        tm.assert_frame_equal(exp_df, df)
+
+    def test_categorical_astype_to_int(self, any_int_dtype):
+        # GH#39402
+
+        df = DataFrame(data={"col1": pd.array([2.0, 1.0, 3.0])})
+        df.col1 = df.col1.astype("category")
+        df.col1 = df.col1.astype(any_int_dtype)
+        expected = DataFrame({"col1": pd.array([2, 1, 3], dtype=any_int_dtype)})
+        tm.assert_frame_equal(df, expected)
+
+    def test_astype_categorical_to_string_missing(self):
+        # https://github.com/pandas-dev/pandas/issues/41797
+        df = DataFrame(["a", "b", np.nan])
+        expected = df.astype(str)
+        cat = df.astype("category")
+        result = cat.astype(str)
+        tm.assert_frame_equal(result, expected)
+
+
+class IntegerArrayNoCopy(pd.core.arrays.IntegerArray):
+    # GH 42501
+
+    def copy(self):
+        assert False
+
+
+class Int16DtypeNoCopy(pd.Int16Dtype):
+    # GH 42501
+
+    @classmethod
+    def construct_array_type(cls):
+        return IntegerArrayNoCopy
+
+
+def test_frame_astype_no_copy():
+    # GH 42501
+    df = DataFrame({"a": [1, 4, None, 5], "b": [6, 7, 8, 9]}, dtype=object)
+    result = df.astype({"a": Int16DtypeNoCopy()}, copy=False)
+
+    assert result.a.dtype == pd.Int16Dtype()
+    assert np.shares_memory(df.b.values, result.b.values)
+
+
+@pytest.mark.skipif(pa_version_under7p0, reason="pyarrow is required for this test")
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+def test_astype_copies(dtype):
+    # GH#50984
+    df = DataFrame({"a": [1, 2, 3]}, dtype=dtype)
+    result = df.astype("int64[pyarrow]", copy=True)
+    df.iloc[0, 0] = 100
+    expected = DataFrame({"a": [1, 2, 3]}, dtype="int64[pyarrow]")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("val", [None, 1, 1.5, np.nan, NaT])
+def test_astype_to_string_not_modifying_input(string_storage, val):
+    # GH#51073
+    df = DataFrame({"a": ["a", "b", val]})
+    expected = df.copy()
+    with option_context("mode.string_storage", string_storage):
+        df.astype("string", copy=False)
+    tm.assert_frame_equal(df, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_at_time.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_at_time.py
new file mode 100644
index 0000000000000000000000000000000000000000..67200396f6375bdeabd106cfd0fa5ecf0850afa8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_at_time.py
@@ -0,0 +1,132 @@
+from datetime import time
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs import timezones
+
+from pandas import (
+    DataFrame,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestAtTime:
+    @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_localized_at_time(self, tzstr, frame_or_series):
+        tz = timezones.maybe_get_tz(tzstr)
+
+        rng = date_range("4/16/2012", "5/1/2012", freq="H")
+        ts = frame_or_series(
+            np.random.default_rng(2).standard_normal(len(rng)), index=rng
+        )
+
+        ts_local = ts.tz_localize(tzstr)
+
+        result = ts_local.at_time(time(10, 0))
+        expected = ts.at_time(time(10, 0)).tz_localize(tzstr)
+        tm.assert_equal(result, expected)
+        assert timezones.tz_compare(result.index.tz, tz)
+
+    def test_at_time(self, frame_or_series):
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 2)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+        rs = ts.at_time(rng[1])
+        assert (rs.index.hour == rng[1].hour).all()
+        assert (rs.index.minute == rng[1].minute).all()
+        assert (rs.index.second == rng[1].second).all()
+
+        result = ts.at_time("9:30")
+        expected = ts.at_time(time(9, 30))
+        tm.assert_equal(result, expected)
+
+    def test_at_time_midnight(self, frame_or_series):
+        # midnight, everything
+        rng = date_range("1/1/2000", "1/31/2000")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 3)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+
+        result = ts.at_time(time(0, 0))
+        tm.assert_equal(result, ts)
+
+    def test_at_time_nonexistent(self, frame_or_series):
+        # time doesn't exist
+        rng = date_range("1/1/2012", freq="23Min", periods=384)
+        ts = DataFrame(np.random.default_rng(2).standard_normal(len(rng)), rng)
+        ts = tm.get_obj(ts, frame_or_series)
+        rs = ts.at_time("16:00")
+        assert len(rs) == 0
+
+    @pytest.mark.parametrize(
+        "hour", ["1:00", "1:00AM", time(1), time(1, tzinfo=pytz.UTC)]
+    )
+    def test_at_time_errors(self, hour):
+        # GH#24043
+        dti = date_range("2018", periods=3, freq="H")
+        df = DataFrame(list(range(len(dti))), index=dti)
+        if getattr(hour, "tzinfo", None) is None:
+            result = df.at_time(hour)
+            expected = df.iloc[1:2]
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(ValueError, match="Index must be timezone"):
+                df.at_time(hour)
+
+    def test_at_time_tz(self):
+        # GH#24043
+        dti = date_range("2018", periods=3, freq="H", tz="US/Pacific")
+        df = DataFrame(list(range(len(dti))), index=dti)
+        result = df.at_time(time(4, tzinfo=pytz.timezone("US/Eastern")))
+        expected = df.iloc[1:2]
+        tm.assert_frame_equal(result, expected)
+
+    def test_at_time_raises(self, frame_or_series):
+        # GH#20725
+        obj = DataFrame([[1, 2, 3], [4, 5, 6]])
+        obj = tm.get_obj(obj, frame_or_series)
+        msg = "Index must be DatetimeIndex"
+        with pytest.raises(TypeError, match=msg):  # index is not a DatetimeIndex
+            obj.at_time("00:00")
+
+    @pytest.mark.parametrize("axis", ["index", "columns", 0, 1])
+    def test_at_time_axis(self, axis):
+        # issue 8839
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(np.random.default_rng(2).standard_normal((len(rng), len(rng))))
+        ts.index, ts.columns = rng, rng
+
+        indices = rng[(rng.hour == 9) & (rng.minute == 30) & (rng.second == 0)]
+
+        if axis in ["index", 0]:
+            expected = ts.loc[indices, :]
+        elif axis in ["columns", 1]:
+            expected = ts.loc[:, indices]
+
+        result = ts.at_time("9:30", axis=axis)
+
+        # Without clearing freq, result has freq 1440T and expected 5T
+        result.index = result.index._with_freq(None)
+        expected.index = expected.index._with_freq(None)
+        tm.assert_frame_equal(result, expected)
+
+    def test_at_time_datetimeindex(self):
+        index = date_range("2012-01-01", "2012-01-05", freq="30min")
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), 5)), index=index
+        )
+        akey = time(12, 0, 0)
+        ainds = [24, 72, 120, 168]
+
+        result = df.at_time(akey)
+        expected = df.loc[akey]
+        expected2 = df.iloc[ainds]
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected2)
+        assert len(result) == 4
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_between_time.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_between_time.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c1e009b04639b64452cde7cf6588cb3d04148d8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_between_time.py
@@ -0,0 +1,227 @@
+from datetime import (
+    datetime,
+    time,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import timezones
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestBetweenTime:
+    @td.skip_if_not_us_locale
+    def test_between_time_formats(self, frame_or_series):
+        # GH#11818
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 2)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+
+        strings = [
+            ("2:00", "2:30"),
+            ("0200", "0230"),
+            ("2:00am", "2:30am"),
+            ("0200am", "0230am"),
+            ("2:00:00", "2:30:00"),
+            ("020000", "023000"),
+            ("2:00:00am", "2:30:00am"),
+            ("020000am", "023000am"),
+        ]
+        expected_length = 28
+
+        for time_string in strings:
+            assert len(ts.between_time(*time_string)) == expected_length
+
+    @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_localized_between_time(self, tzstr, frame_or_series):
+        tz = timezones.maybe_get_tz(tzstr)
+
+        rng = date_range("4/16/2012", "5/1/2012", freq="H")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+        if frame_or_series is DataFrame:
+            ts = ts.to_frame()
+
+        ts_local = ts.tz_localize(tzstr)
+
+        t1, t2 = time(10, 0), time(11, 0)
+        result = ts_local.between_time(t1, t2)
+        expected = ts.between_time(t1, t2).tz_localize(tzstr)
+        tm.assert_equal(result, expected)
+        assert timezones.tz_compare(result.index.tz, tz)
+
+    def test_between_time_types(self, frame_or_series):
+        # GH11818
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        obj = DataFrame({"A": 0}, index=rng)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\] to a time"
+        with pytest.raises(ValueError, match=msg):
+            obj.between_time(datetime(2010, 1, 2, 1), datetime(2010, 1, 2, 5))
+
+    def test_between_time(self, inclusive_endpoints_fixture, frame_or_series):
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 2)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+
+        stime = time(0, 0)
+        etime = time(1, 0)
+        inclusive = inclusive_endpoints_fixture
+
+        filtered = ts.between_time(stime, etime, inclusive=inclusive)
+        exp_len = 13 * 4 + 1
+
+        if inclusive in ["right", "neither"]:
+            exp_len -= 5
+        if inclusive in ["left", "neither"]:
+            exp_len -= 4
+
+        assert len(filtered) == exp_len
+        for rs in filtered.index:
+            t = rs.time()
+            if inclusive in ["left", "both"]:
+                assert t >= stime
+            else:
+                assert t > stime
+
+            if inclusive in ["right", "both"]:
+                assert t <= etime
+            else:
+                assert t < etime
+
+        result = ts.between_time("00:00", "01:00")
+        expected = ts.between_time(stime, etime)
+        tm.assert_equal(result, expected)
+
+        # across midnight
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 2)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+        stime = time(22, 0)
+        etime = time(9, 0)
+
+        filtered = ts.between_time(stime, etime, inclusive=inclusive)
+        exp_len = (12 * 11 + 1) * 4 + 1
+        if inclusive in ["right", "neither"]:
+            exp_len -= 4
+        if inclusive in ["left", "neither"]:
+            exp_len -= 4
+
+        assert len(filtered) == exp_len
+        for rs in filtered.index:
+            t = rs.time()
+            if inclusive in ["left", "both"]:
+                assert (t >= stime) or (t <= etime)
+            else:
+                assert (t > stime) or (t <= etime)
+
+            if inclusive in ["right", "both"]:
+                assert (t <= etime) or (t >= stime)
+            else:
+                assert (t < etime) or (t >= stime)
+
+    def test_between_time_raises(self, frame_or_series):
+        # GH#20725
+        obj = DataFrame([[1, 2, 3], [4, 5, 6]])
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = "Index must be DatetimeIndex"
+        with pytest.raises(TypeError, match=msg):  # index is not a DatetimeIndex
+            obj.between_time(start_time="00:00", end_time="12:00")
+
+    def test_between_time_axis(self, frame_or_series):
+        # GH#8839
+        rng = date_range("1/1/2000", periods=100, freq="10min")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+        if frame_or_series is DataFrame:
+            ts = ts.to_frame()
+
+        stime, etime = ("08:00:00", "09:00:00")
+        expected_length = 7
+
+        assert len(ts.between_time(stime, etime)) == expected_length
+        assert len(ts.between_time(stime, etime, axis=0)) == expected_length
+        msg = f"No axis named {ts.ndim} for object type {type(ts).__name__}"
+        with pytest.raises(ValueError, match=msg):
+            ts.between_time(stime, etime, axis=ts.ndim)
+
+    def test_between_time_axis_aliases(self, axis):
+        # GH#8839
+        rng = date_range("1/1/2000", periods=100, freq="10min")
+        ts = DataFrame(np.random.default_rng(2).standard_normal((len(rng), len(rng))))
+        stime, etime = ("08:00:00", "09:00:00")
+        exp_len = 7
+
+        if axis in ["index", 0]:
+            ts.index = rng
+            assert len(ts.between_time(stime, etime)) == exp_len
+            assert len(ts.between_time(stime, etime, axis=0)) == exp_len
+
+        if axis in ["columns", 1]:
+            ts.columns = rng
+            selected = ts.between_time(stime, etime, axis=1).columns
+            assert len(selected) == exp_len
+
+    def test_between_time_axis_raises(self, axis):
+        # issue 8839
+        rng = date_range("1/1/2000", periods=100, freq="10min")
+        mask = np.arange(0, len(rng))
+        rand_data = np.random.default_rng(2).standard_normal((len(rng), len(rng)))
+        ts = DataFrame(rand_data, index=rng, columns=rng)
+        stime, etime = ("08:00:00", "09:00:00")
+
+        msg = "Index must be DatetimeIndex"
+        if axis in ["columns", 1]:
+            ts.index = mask
+            with pytest.raises(TypeError, match=msg):
+                ts.between_time(stime, etime)
+            with pytest.raises(TypeError, match=msg):
+                ts.between_time(stime, etime, axis=0)
+
+        if axis in ["index", 0]:
+            ts.columns = mask
+            with pytest.raises(TypeError, match=msg):
+                ts.between_time(stime, etime, axis=1)
+
+    def test_between_time_datetimeindex(self):
+        index = date_range("2012-01-01", "2012-01-05", freq="30min")
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), 5)), index=index
+        )
+        bkey = slice(time(13, 0, 0), time(14, 0, 0))
+        binds = [26, 27, 28, 74, 75, 76, 122, 123, 124, 170, 171, 172]
+
+        result = df.between_time(bkey.start, bkey.stop)
+        expected = df.loc[bkey]
+        expected2 = df.iloc[binds]
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected2)
+        assert len(result) == 12
+
+    def test_between_time_incorrect_arg_inclusive(self):
+        # GH40245
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 2)), index=rng
+        )
+
+        stime = time(0, 0)
+        etime = time(1, 0)
+        inclusive = "bad_string"
+        msg = "Inclusive has to be either 'both', 'neither', 'left' or 'right'"
+        with pytest.raises(ValueError, match=msg):
+            ts.between_time(stime, etime, inclusive=inclusive)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_clip.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7b221d84ab780221131c331dc967c91ef0323c9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_clip.py
@@ -0,0 +1,190 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameClip:
+    def test_clip(self, float_frame):
+        median = float_frame.median().median()
+        original = float_frame.copy()
+
+        double = float_frame.clip(upper=median, lower=median)
+        assert not (double.values != median).any()
+
+        # Verify that float_frame was not changed inplace
+        assert (float_frame.values == original.values).all()
+
+    def test_inplace_clip(self, float_frame):
+        # GH#15388
+        median = float_frame.median().median()
+        frame_copy = float_frame.copy()
+
+        return_value = frame_copy.clip(upper=median, lower=median, inplace=True)
+        assert return_value is None
+        assert not (frame_copy.values != median).any()
+
+    def test_dataframe_clip(self):
+        # GH#2747
+        df = DataFrame(np.random.default_rng(2).standard_normal((1000, 2)))
+
+        for lb, ub in [(-1, 1), (1, -1)]:
+            clipped_df = df.clip(lb, ub)
+
+            lb, ub = min(lb, ub), max(ub, lb)
+            lb_mask = df.values <= lb
+            ub_mask = df.values >= ub
+            mask = ~lb_mask & ~ub_mask
+            assert (clipped_df.values[lb_mask] == lb).all()
+            assert (clipped_df.values[ub_mask] == ub).all()
+            assert (clipped_df.values[mask] == df.values[mask]).all()
+
+    def test_clip_mixed_numeric(self):
+        # clip on mixed integer or floats
+        # GH#24162, clipping now preserves numeric types per column
+        df = DataFrame({"A": [1, 2, 3], "B": [1.0, np.nan, 3.0]})
+        result = df.clip(1, 2)
+        expected = DataFrame({"A": [1, 2, 2], "B": [1.0, np.nan, 2.0]})
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame([[1, 2, 3.4], [3, 4, 5.6]], columns=["foo", "bar", "baz"])
+        expected = df.dtypes
+        result = df.clip(upper=3).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_clip_against_series(self, inplace):
+        # GH#6966
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((1000, 2)))
+        lb = Series(np.random.default_rng(2).standard_normal(1000))
+        ub = lb + 1
+
+        original = df.copy()
+        clipped_df = df.clip(lb, ub, axis=0, inplace=inplace)
+
+        if inplace:
+            clipped_df = df
+
+        for i in range(2):
+            lb_mask = original.iloc[:, i] <= lb
+            ub_mask = original.iloc[:, i] >= ub
+            mask = ~lb_mask & ~ub_mask
+
+            result = clipped_df.loc[lb_mask, i]
+            tm.assert_series_equal(result, lb[lb_mask], check_names=False)
+            assert result.name == i
+
+            result = clipped_df.loc[ub_mask, i]
+            tm.assert_series_equal(result, ub[ub_mask], check_names=False)
+            assert result.name == i
+
+            tm.assert_series_equal(clipped_df.loc[mask, i], df.loc[mask, i])
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("lower", [[2, 3, 4], np.asarray([2, 3, 4])])
+    @pytest.mark.parametrize(
+        "axis,res",
+        [
+            (0, [[2.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 7.0, 7.0]]),
+            (1, [[2.0, 3.0, 4.0], [4.0, 5.0, 6.0], [5.0, 6.0, 7.0]]),
+        ],
+    )
+    def test_clip_against_list_like(self, simple_frame, inplace, lower, axis, res):
+        # GH#15390
+        original = simple_frame.copy(deep=True)
+
+        result = original.clip(lower=lower, upper=[5, 6, 7], axis=axis, inplace=inplace)
+
+        expected = DataFrame(res, columns=original.columns, index=original.index)
+        if inplace:
+            result = original
+        tm.assert_frame_equal(result, expected, check_exact=True)
+
+    @pytest.mark.parametrize("axis", [0, 1, None])
+    def test_clip_against_frame(self, axis):
+        df = DataFrame(np.random.default_rng(2).standard_normal((1000, 2)))
+        lb = DataFrame(np.random.default_rng(2).standard_normal((1000, 2)))
+        ub = lb + 1
+
+        clipped_df = df.clip(lb, ub, axis=axis)
+
+        lb_mask = df <= lb
+        ub_mask = df >= ub
+        mask = ~lb_mask & ~ub_mask
+
+        tm.assert_frame_equal(clipped_df[lb_mask], lb[lb_mask])
+        tm.assert_frame_equal(clipped_df[ub_mask], ub[ub_mask])
+        tm.assert_frame_equal(clipped_df[mask], df[mask])
+
+    def test_clip_against_unordered_columns(self):
+        # GH#20911
+        df1 = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 4)),
+            columns=["A", "B", "C", "D"],
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 4)),
+            columns=["D", "A", "B", "C"],
+        )
+        df3 = DataFrame(df2.values - 1, columns=["B", "D", "C", "A"])
+        result_upper = df1.clip(lower=0, upper=df2)
+        expected_upper = df1.clip(lower=0, upper=df2[df1.columns])
+        result_lower = df1.clip(lower=df3, upper=3)
+        expected_lower = df1.clip(lower=df3[df1.columns], upper=3)
+        result_lower_upper = df1.clip(lower=df3, upper=df2)
+        expected_lower_upper = df1.clip(lower=df3[df1.columns], upper=df2[df1.columns])
+        tm.assert_frame_equal(result_upper, expected_upper)
+        tm.assert_frame_equal(result_lower, expected_lower)
+        tm.assert_frame_equal(result_lower_upper, expected_lower_upper)
+
+    def test_clip_with_na_args(self, float_frame):
+        """Should process np.nan argument as None"""
+        # GH#17276
+        tm.assert_frame_equal(float_frame.clip(np.nan), float_frame)
+        tm.assert_frame_equal(float_frame.clip(upper=np.nan, lower=np.nan), float_frame)
+
+        # GH#19992 and adjusted in GH#40420
+        df = DataFrame({"col_0": [1, 2, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]})
+
+        result = df.clip(lower=[4, 5, np.nan], axis=0)
+        expected = DataFrame(
+            {"col_0": [4, 5, 3], "col_1": [4, 5, 6], "col_2": [7, 8, 9]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.clip(lower=[4, 5, np.nan], axis=1)
+        expected = DataFrame(
+            {"col_0": [4, 4, 4], "col_1": [5, 5, 6], "col_2": [7, 8, 9]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # GH#40420
+        data = {"col_0": [9, -3, 0, -1, 5], "col_1": [-2, -7, 6, 8, -5]}
+        df = DataFrame(data)
+        t = Series([2, -4, np.nan, 6, 3])
+        result = df.clip(lower=t, axis=0)
+        expected = DataFrame({"col_0": [9, -3, 0, 6, 5], "col_1": [2, -4, 6, 8, 3]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_clip_int_data_with_float_bound(self):
+        # GH51472
+        df = DataFrame({"a": [1, 2, 3]})
+        result = df.clip(lower=1.5)
+        expected = DataFrame({"a": [1.5, 2.0, 3.0]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_clip_with_list_bound(self):
+        # GH#54817
+        df = DataFrame([1, 5])
+        expected = DataFrame([3, 5])
+        result = df.clip([3])
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame([1, 3])
+        result = df.clip(upper=[3])
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_combine.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_combine.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc6a67e4e1f320dbb71220d33ba03eaf788bcb4b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_combine.py
@@ -0,0 +1,47 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestCombine:
+    @pytest.mark.parametrize(
+        "data",
+        [
+            pd.date_range("2000", periods=4),
+            pd.date_range("2000", periods=4, tz="US/Central"),
+            pd.period_range("2000", periods=4),
+            pd.timedelta_range(0, periods=4),
+        ],
+    )
+    def test_combine_datetlike_udf(self, data):
+        # GH#23079
+        df = pd.DataFrame({"A": data})
+        other = df.copy()
+        df.iloc[1, 0] = None
+
+        def combiner(a, b):
+            return b
+
+        result = df.combine(other, combiner)
+        tm.assert_frame_equal(result, other)
+
+    def test_combine_generic(self, float_frame):
+        df1 = float_frame
+        df2 = float_frame.loc[float_frame.index[:-5], ["A", "B", "C"]]
+
+        combined = df1.combine(df2, np.add)
+        combined2 = df2.combine(df1, np.add)
+        assert combined["D"].isna().all()
+        assert combined2["D"].isna().all()
+
+        chunk = combined.loc[combined.index[:-5], ["A", "B", "C"]]
+        chunk2 = combined2.loc[combined2.index[:-5], ["A", "B", "C"]]
+
+        exp = (
+            float_frame.loc[float_frame.index[:-5], ["A", "B", "C"]].reindex_like(chunk)
+            * 2
+        )
+        tm.assert_frame_equal(chunk, exp)
+        tm.assert_frame_equal(chunk2, exp)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_combine_first.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_combine_first.py
new file mode 100644
index 0000000000000000000000000000000000000000..156e50d50a9ef5a240af25d9c795eac8c902a2b0
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_combine_first.py
@@ -0,0 +1,548 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.common import is_dtype_equal
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameCombineFirst:
+    def test_combine_first_mixed(self):
+        a = Series(["a", "b"], index=range(2))
+        b = Series(range(2), index=range(2))
+        f = DataFrame({"A": a, "B": b})
+
+        a = Series(["a", "b"], index=range(5, 7))
+        b = Series(range(2), index=range(5, 7))
+        g = DataFrame({"A": a, "B": b})
+
+        exp = DataFrame({"A": list("abab"), "B": [0, 1, 0, 1]}, index=[0, 1, 5, 6])
+        combined = f.combine_first(g)
+        tm.assert_frame_equal(combined, exp)
+
+    def test_combine_first(self, float_frame):
+        # disjoint
+        head, tail = float_frame[:5], float_frame[5:]
+
+        combined = head.combine_first(tail)
+        reordered_frame = float_frame.reindex(combined.index)
+        tm.assert_frame_equal(combined, reordered_frame)
+        assert tm.equalContents(combined.columns, float_frame.columns)
+        tm.assert_series_equal(combined["A"], reordered_frame["A"])
+
+        # same index
+        fcopy = float_frame.copy()
+        fcopy["A"] = 1
+        del fcopy["C"]
+
+        fcopy2 = float_frame.copy()
+        fcopy2["B"] = 0
+        del fcopy2["D"]
+
+        combined = fcopy.combine_first(fcopy2)
+
+        assert (combined["A"] == 1).all()
+        tm.assert_series_equal(combined["B"], fcopy["B"])
+        tm.assert_series_equal(combined["C"], fcopy2["C"])
+        tm.assert_series_equal(combined["D"], fcopy["D"])
+
+        # overlap
+        head, tail = reordered_frame[:10].copy(), reordered_frame
+        head["A"] = 1
+
+        combined = head.combine_first(tail)
+        assert (combined["A"][:10] == 1).all()
+
+        # reverse overlap
+        tail.iloc[:10, tail.columns.get_loc("A")] = 0
+        combined = tail.combine_first(head)
+        assert (combined["A"][:10] == 0).all()
+
+        # no overlap
+        f = float_frame[:10]
+        g = float_frame[10:]
+        combined = f.combine_first(g)
+        tm.assert_series_equal(combined["A"].reindex(f.index), f["A"])
+        tm.assert_series_equal(combined["A"].reindex(g.index), g["A"])
+
+        # corner cases
+        comb = float_frame.combine_first(DataFrame())
+        tm.assert_frame_equal(comb, float_frame)
+
+        comb = DataFrame().combine_first(float_frame)
+        tm.assert_frame_equal(comb, float_frame)
+
+        comb = float_frame.combine_first(DataFrame(index=["faz", "boo"]))
+        assert "faz" in comb.index
+
+        # #2525
+        df = DataFrame({"a": [1]}, index=[datetime(2012, 1, 1)])
+        df2 = DataFrame(columns=["b"])
+        result = df.combine_first(df2)
+        assert "b" in result
+
+    def test_combine_first_mixed_bug(self):
+        idx = Index(["a", "b", "c", "e"])
+        ser1 = Series([5.0, -9.0, 4.0, 100.0], index=idx)
+        ser2 = Series(["a", "b", "c", "e"], index=idx)
+        ser3 = Series([12, 4, 5, 97], index=idx)
+
+        frame1 = DataFrame({"col0": ser1, "col2": ser2, "col3": ser3})
+
+        idx = Index(["a", "b", "c", "f"])
+        ser1 = Series([5.0, -9.0, 4.0, 100.0], index=idx)
+        ser2 = Series(["a", "b", "c", "f"], index=idx)
+        ser3 = Series([12, 4, 5, 97], index=idx)
+
+        frame2 = DataFrame({"col1": ser1, "col2": ser2, "col5": ser3})
+
+        combined = frame1.combine_first(frame2)
+        assert len(combined.columns) == 5
+
+    def test_combine_first_same_as_in_update(self):
+        # gh 3016 (same as in update)
+        df = DataFrame(
+            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
+            columns=["A", "B", "bool1", "bool2"],
+        )
+
+        other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
+        result = df.combine_first(other)
+        tm.assert_frame_equal(result, df)
+
+        df.loc[0, "A"] = np.nan
+        result = df.combine_first(other)
+        df.loc[0, "A"] = 45
+        tm.assert_frame_equal(result, df)
+
+    def test_combine_first_doc_example(self):
+        # doc example
+        df1 = DataFrame(
+            {"A": [1.0, np.nan, 3.0, 5.0, np.nan], "B": [np.nan, 2.0, 3.0, np.nan, 6.0]}
+        )
+
+        df2 = DataFrame(
+            {
+                "A": [5.0, 2.0, 4.0, np.nan, 3.0, 7.0],
+                "B": [np.nan, np.nan, 3.0, 4.0, 6.0, 8.0],
+            }
+        )
+
+        result = df1.combine_first(df2)
+        expected = DataFrame({"A": [1, 2, 3, 5, 3, 7.0], "B": [np.nan, 2, 3, 4, 6, 8]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_combine_first_return_obj_type_with_bools(self):
+        # GH3552
+
+        df1 = DataFrame(
+            [[np.nan, 3.0, True], [-4.6, np.nan, True], [np.nan, 7.0, False]]
+        )
+        df2 = DataFrame([[-42.6, np.nan, True], [-5.0, 1.6, False]], index=[1, 2])
+
+        expected = Series([True, True, False], name=2, dtype=bool)
+
+        result_12 = df1.combine_first(df2)[2]
+        tm.assert_series_equal(result_12, expected)
+
+        result_21 = df2.combine_first(df1)[2]
+        tm.assert_series_equal(result_21, expected)
+
+    @pytest.mark.parametrize(
+        "data1, data2, data_expected",
+        (
+            (
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+                [pd.NaT, pd.NaT, pd.NaT],
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+            ),
+            (
+                [pd.NaT, pd.NaT, pd.NaT],
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+            ),
+            (
+                [datetime(2000, 1, 2), pd.NaT, pd.NaT],
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+                [datetime(2000, 1, 2), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+            ),
+            (
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+                [datetime(2000, 1, 2), pd.NaT, pd.NaT],
+                [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)],
+            ),
+        ),
+    )
+    def test_combine_first_convert_datatime_correctly(
+        self, data1, data2, data_expected
+    ):
+        # GH 3593
+
+        df1, df2 = DataFrame({"a": data1}), DataFrame({"a": data2})
+        result = df1.combine_first(df2)
+        expected = DataFrame({"a": data_expected})
+        tm.assert_frame_equal(result, expected)
+
+    def test_combine_first_align_nan(self):
+        # GH 7509 (not fixed)
+        dfa = DataFrame([[pd.Timestamp("2011-01-01"), 2]], columns=["a", "b"])
+        dfb = DataFrame([[4], [5]], columns=["b"])
+        assert dfa["a"].dtype == "datetime64[ns]"
+        assert dfa["b"].dtype == "int64"
+
+        res = dfa.combine_first(dfb)
+        exp = DataFrame(
+            {"a": [pd.Timestamp("2011-01-01"), pd.NaT], "b": [2, 5]},
+            columns=["a", "b"],
+        )
+        tm.assert_frame_equal(res, exp)
+        assert res["a"].dtype == "datetime64[ns]"
+        # TODO: this must be int64
+        assert res["b"].dtype == "int64"
+
+        res = dfa.iloc[:0].combine_first(dfb)
+        exp = DataFrame({"a": [np.nan, np.nan], "b": [4, 5]}, columns=["a", "b"])
+        tm.assert_frame_equal(res, exp)
+        # TODO: this must be datetime64
+        assert res["a"].dtype == "float64"
+        # TODO: this must be int64
+        assert res["b"].dtype == "int64"
+
+    def test_combine_first_timezone(self):
+        # see gh-7630
+        data1 = pd.to_datetime("20100101 01:01").tz_localize("UTC")
+        df1 = DataFrame(
+            columns=["UTCdatetime", "abc"],
+            data=data1,
+            index=pd.date_range("20140627", periods=1),
+        )
+        data2 = pd.to_datetime("20121212 12:12").tz_localize("UTC")
+        df2 = DataFrame(
+            columns=["UTCdatetime", "xyz"],
+            data=data2,
+            index=pd.date_range("20140628", periods=1),
+        )
+        res = df2[["UTCdatetime"]].combine_first(df1)
+        exp = DataFrame(
+            {
+                "UTCdatetime": [
+                    pd.Timestamp("2010-01-01 01:01", tz="UTC"),
+                    pd.Timestamp("2012-12-12 12:12", tz="UTC"),
+                ],
+                "abc": [pd.Timestamp("2010-01-01 01:01:00", tz="UTC"), pd.NaT],
+            },
+            columns=["UTCdatetime", "abc"],
+            index=pd.date_range("20140627", periods=2, freq="D"),
+        )
+        assert res["UTCdatetime"].dtype == "datetime64[ns, UTC]"
+        assert res["abc"].dtype == "datetime64[ns, UTC]"
+
+        tm.assert_frame_equal(res, exp)
+
+        # see gh-10567
+        dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="UTC")
+        df1 = DataFrame({"DATE": dts1})
+        dts2 = pd.date_range("2015-01-03", "2015-01-05", tz="UTC")
+        df2 = DataFrame({"DATE": dts2})
+
+        res = df1.combine_first(df2)
+        tm.assert_frame_equal(res, df1)
+        assert res["DATE"].dtype == "datetime64[ns, UTC]"
+
+        dts1 = pd.DatetimeIndex(
+            ["2011-01-01", "NaT", "2011-01-03", "2011-01-04"], tz="US/Eastern"
+        )
+        df1 = DataFrame({"DATE": dts1}, index=[1, 3, 5, 7])
+        dts2 = pd.DatetimeIndex(
+            ["2012-01-01", "2012-01-02", "2012-01-03"], tz="US/Eastern"
+        )
+        df2 = DataFrame({"DATE": dts2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = pd.DatetimeIndex(
+            [
+                "2011-01-01",
+                "2012-01-01",
+                "NaT",
+                "2012-01-02",
+                "2011-01-03",
+                "2011-01-04",
+            ],
+            tz="US/Eastern",
+        )
+        exp = DataFrame({"DATE": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+
+        # different tz
+        dts1 = pd.date_range("2015-01-01", "2015-01-05", tz="US/Eastern")
+        df1 = DataFrame({"DATE": dts1})
+        dts2 = pd.date_range("2015-01-03", "2015-01-05")
+        df2 = DataFrame({"DATE": dts2})
+
+        # if df1 doesn't have NaN, keep its dtype
+        res = df1.combine_first(df2)
+        tm.assert_frame_equal(res, df1)
+        assert res["DATE"].dtype == "datetime64[ns, US/Eastern]"
+
+        dts1 = pd.date_range("2015-01-01", "2015-01-02", tz="US/Eastern")
+        df1 = DataFrame({"DATE": dts1})
+        dts2 = pd.date_range("2015-01-01", "2015-01-03")
+        df2 = DataFrame({"DATE": dts2})
+
+        res = df1.combine_first(df2)
+        exp_dts = [
+            pd.Timestamp("2015-01-01", tz="US/Eastern"),
+            pd.Timestamp("2015-01-02", tz="US/Eastern"),
+            pd.Timestamp("2015-01-03"),
+        ]
+        exp = DataFrame({"DATE": exp_dts})
+        tm.assert_frame_equal(res, exp)
+        assert res["DATE"].dtype == "object"
+
+    def test_combine_first_timedelta(self):
+        data1 = pd.TimedeltaIndex(["1 day", "NaT", "3 day", "4day"])
+        df1 = DataFrame({"TD": data1}, index=[1, 3, 5, 7])
+        data2 = pd.TimedeltaIndex(["10 day", "11 day", "12 day"])
+        df2 = DataFrame({"TD": data2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = pd.TimedeltaIndex(
+            ["1 day", "10 day", "NaT", "11 day", "3 day", "4 day"]
+        )
+        exp = DataFrame({"TD": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+        assert res["TD"].dtype == "timedelta64[ns]"
+
+    def test_combine_first_period(self):
+        data1 = pd.PeriodIndex(["2011-01", "NaT", "2011-03", "2011-04"], freq="M")
+        df1 = DataFrame({"P": data1}, index=[1, 3, 5, 7])
+        data2 = pd.PeriodIndex(["2012-01-01", "2012-02", "2012-03"], freq="M")
+        df2 = DataFrame({"P": data2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = pd.PeriodIndex(
+            ["2011-01", "2012-01", "NaT", "2012-02", "2011-03", "2011-04"], freq="M"
+        )
+        exp = DataFrame({"P": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+        assert res["P"].dtype == data1.dtype
+
+        # different freq
+        dts2 = pd.PeriodIndex(["2012-01-01", "2012-01-02", "2012-01-03"], freq="D")
+        df2 = DataFrame({"P": dts2}, index=[2, 4, 5])
+
+        res = df1.combine_first(df2)
+        exp_dts = [
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2012-01-01", freq="D"),
+            pd.NaT,
+            pd.Period("2012-01-02", freq="D"),
+            pd.Period("2011-03", freq="M"),
+            pd.Period("2011-04", freq="M"),
+        ]
+        exp = DataFrame({"P": exp_dts}, index=[1, 2, 3, 4, 5, 7])
+        tm.assert_frame_equal(res, exp)
+        assert res["P"].dtype == "object"
+
+    def test_combine_first_int(self):
+        # GH14687 - integer series that do no align exactly
+
+        df1 = DataFrame({"a": [0, 1, 3, 5]}, dtype="int64")
+        df2 = DataFrame({"a": [1, 4]}, dtype="int64")
+
+        result_12 = df1.combine_first(df2)
+        expected_12 = DataFrame({"a": [0, 1, 3, 5]})
+        tm.assert_frame_equal(result_12, expected_12)
+
+        result_21 = df2.combine_first(df1)
+        expected_21 = DataFrame({"a": [1, 4, 3, 5]})
+        tm.assert_frame_equal(result_21, expected_21)
+
+    @pytest.mark.parametrize("val", [1, 1.0])
+    def test_combine_first_with_asymmetric_other(self, val):
+        # see gh-20699
+        df1 = DataFrame({"isNum": [val]})
+        df2 = DataFrame({"isBool": [True]})
+
+        res = df1.combine_first(df2)
+        exp = DataFrame({"isBool": [True], "isNum": [val]})
+
+        tm.assert_frame_equal(res, exp)
+
+    def test_combine_first_string_dtype_only_na(self, nullable_string_dtype):
+        # GH: 37519
+        df = DataFrame(
+            {"a": ["962", "85"], "b": [pd.NA] * 2}, dtype=nullable_string_dtype
+        )
+        df2 = DataFrame({"a": ["85"], "b": [pd.NA]}, dtype=nullable_string_dtype)
+        df.set_index(["a", "b"], inplace=True)
+        df2.set_index(["a", "b"], inplace=True)
+        result = df.combine_first(df2)
+        expected = DataFrame(
+            {"a": ["962", "85"], "b": [pd.NA] * 2}, dtype=nullable_string_dtype
+        ).set_index(["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "scalar1, scalar2",
+    [
+        (datetime(2020, 1, 1), datetime(2020, 1, 2)),
+        (pd.Period("2020-01-01", "D"), pd.Period("2020-01-02", "D")),
+        (pd.Timedelta("89 days"), pd.Timedelta("60 min")),
+        (pd.Interval(left=0, right=1), pd.Interval(left=2, right=3, closed="left")),
+    ],
+)
+def test_combine_first_timestamp_bug(scalar1, scalar2, nulls_fixture):
+    # GH28481
+    na_value = nulls_fixture
+
+    frame = DataFrame([[na_value, na_value]], columns=["a", "b"])
+    other = DataFrame([[scalar1, scalar2]], columns=["b", "c"])
+
+    common_dtype = find_common_type([frame.dtypes["b"], other.dtypes["b"]])
+
+    if is_dtype_equal(common_dtype, "object") or frame.dtypes["b"] == other.dtypes["b"]:
+        val = scalar1
+    else:
+        val = na_value
+
+    result = frame.combine_first(other)
+
+    expected = DataFrame([[na_value, val, scalar2]], columns=["a", "b", "c"])
+
+    expected["b"] = expected["b"].astype(common_dtype)
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_combine_first_timestamp_bug_NaT():
+    # GH28481
+    frame = DataFrame([[pd.NaT, pd.NaT]], columns=["a", "b"])
+    other = DataFrame(
+        [[datetime(2020, 1, 1), datetime(2020, 1, 2)]], columns=["b", "c"]
+    )
+
+    result = frame.combine_first(other)
+    expected = DataFrame(
+        [[pd.NaT, datetime(2020, 1, 1), datetime(2020, 1, 2)]], columns=["a", "b", "c"]
+    )
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_combine_first_with_nan_multiindex():
+    # gh-36562
+
+    mi1 = MultiIndex.from_arrays(
+        [["b", "b", "c", "a", "b", np.nan], [1, 2, 3, 4, 5, 6]], names=["a", "b"]
+    )
+    df = DataFrame({"c": [1, 1, 1, 1, 1, 1]}, index=mi1)
+    mi2 = MultiIndex.from_arrays(
+        [["a", "b", "c", "a", "b", "d"], [1, 1, 1, 1, 1, 1]], names=["a", "b"]
+    )
+    s = Series([1, 2, 3, 4, 5, 6], index=mi2)
+    res = df.combine_first(DataFrame({"d": s}))
+    mi_expected = MultiIndex.from_arrays(
+        [
+            ["a", "a", "a", "b", "b", "b", "b", "c", "c", "d", np.nan],
+            [1, 1, 4, 1, 1, 2, 5, 1, 3, 1, 6],
+        ],
+        names=["a", "b"],
+    )
+    expected = DataFrame(
+        {
+            "c": [np.nan, np.nan, 1, 1, 1, 1, 1, np.nan, 1, np.nan, 1],
+            "d": [1.0, 4.0, np.nan, 2.0, 5.0, np.nan, np.nan, 3.0, np.nan, 6.0, np.nan],
+        },
+        index=mi_expected,
+    )
+    tm.assert_frame_equal(res, expected)
+
+
+def test_combine_preserve_dtypes():
+    # GH7509
+    a_column = Series(["a", "b"], index=range(2))
+    b_column = Series(range(2), index=range(2))
+    df1 = DataFrame({"A": a_column, "B": b_column})
+
+    c_column = Series(["a", "b"], index=range(5, 7))
+    b_column = Series(range(-1, 1), index=range(5, 7))
+    df2 = DataFrame({"B": b_column, "C": c_column})
+
+    expected = DataFrame(
+        {
+            "A": ["a", "b", np.nan, np.nan],
+            "B": [0, 1, -1, 0],
+            "C": [np.nan, np.nan, "a", "b"],
+        },
+        index=[0, 1, 5, 6],
+    )
+    combined = df1.combine_first(df2)
+    tm.assert_frame_equal(combined, expected)
+
+
+def test_combine_first_duplicates_rows_for_nan_index_values():
+    # GH39881
+    df1 = DataFrame(
+        {"x": [9, 10, 11]},
+        index=MultiIndex.from_arrays([[1, 2, 3], [np.nan, 5, 6]], names=["a", "b"]),
+    )
+
+    df2 = DataFrame(
+        {"y": [12, 13, 14]},
+        index=MultiIndex.from_arrays([[1, 2, 4], [np.nan, 5, 7]], names=["a", "b"]),
+    )
+
+    expected = DataFrame(
+        {
+            "x": [9.0, 10.0, 11.0, np.nan],
+            "y": [12.0, 13.0, np.nan, 14.0],
+        },
+        index=MultiIndex.from_arrays(
+            [[1, 2, 3, 4], [np.nan, 5, 6, 7]], names=["a", "b"]
+        ),
+    )
+    combined = df1.combine_first(df2)
+    tm.assert_frame_equal(combined, expected)
+
+
+def test_combine_first_int64_not_cast_to_float64():
+    # GH 28613
+    df_1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    df_2 = DataFrame({"A": [1, 20, 30], "B": [40, 50, 60], "C": [12, 34, 65]})
+    result = df_1.combine_first(df_2)
+    expected = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [12, 34, 65]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_midx_losing_dtype():
+    # GH#49830
+    midx = MultiIndex.from_arrays([[0, 0], [np.nan, np.nan]])
+    midx2 = MultiIndex.from_arrays([[1, 1], [np.nan, np.nan]])
+    df1 = DataFrame({"a": [None, 4]}, index=midx)
+    df2 = DataFrame({"a": [3, 3]}, index=midx2)
+    result = df1.combine_first(df2)
+    expected_midx = MultiIndex.from_arrays(
+        [[0, 0, 1, 1], [np.nan, np.nan, np.nan, np.nan]]
+    )
+    expected = DataFrame({"a": [np.nan, 4, 3, 3]}, index=expected_midx)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_combine_first_empty_columns():
+    left = DataFrame(columns=["a", "b"])
+    right = DataFrame(columns=["a", "c"])
+    result = left.combine_first(right)
+    expected = DataFrame(columns=["a", "b", "c"])
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_compare.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4d0a7068a3a650beb11529065d0b62ab702143b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_compare.py
@@ -0,0 +1,305 @@
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import np_version_gte1p25
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("align_axis", [0, 1, "index", "columns"])
+def test_compare_axis(align_axis):
+    # GH#30429
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+    df2.loc[2, "col3"] = 4.0
+
+    result = df.compare(df2, align_axis=align_axis)
+
+    if align_axis in (1, "columns"):
+        indices = pd.Index([0, 2])
+        columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+        expected = pd.DataFrame(
+            [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]],
+            index=indices,
+            columns=columns,
+        )
+    else:
+        indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+        columns = pd.Index(["col1", "col3"])
+        expected = pd.DataFrame(
+            [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]],
+            index=indices,
+            columns=columns,
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep_shape, keep_equal",
+    [
+        (True, False),
+        (False, True),
+        (True, True),
+        # False, False case is already covered in test_compare_axis
+    ],
+)
+def test_compare_various_formats(keep_shape, keep_equal):
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+    df2.loc[2, "col3"] = 4.0
+
+    result = df.compare(df2, keep_shape=keep_shape, keep_equal=keep_equal)
+
+    if keep_shape:
+        indices = pd.Index([0, 1, 2])
+        columns = pd.MultiIndex.from_product(
+            [["col1", "col2", "col3"], ["self", "other"]]
+        )
+        if keep_equal:
+            expected = pd.DataFrame(
+                [
+                    ["a", "c", 1.0, 1.0, 1.0, 1.0],
+                    ["b", "b", 2.0, 2.0, 2.0, 2.0],
+                    ["c", "c", np.nan, np.nan, 3.0, 4.0],
+                ],
+                index=indices,
+                columns=columns,
+            )
+        else:
+            expected = pd.DataFrame(
+                [
+                    ["a", "c", np.nan, np.nan, np.nan, np.nan],
+                    [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+                    [np.nan, np.nan, np.nan, np.nan, 3.0, 4.0],
+                ],
+                index=indices,
+                columns=columns,
+            )
+    else:
+        indices = pd.Index([0, 2])
+        columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+        expected = pd.DataFrame(
+            [["a", "c", 1.0, 1.0], ["c", "c", 3.0, 4.0]], index=indices, columns=columns
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_equal_nulls():
+    # We want to make sure two NaNs are considered the same
+    # and dropped where applicable
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+
+    result = df.compare(df2)
+    indices = pd.Index([0])
+    columns = pd.MultiIndex.from_product([["col1"], ["self", "other"]])
+    expected = pd.DataFrame([["a", "c"]], index=indices, columns=columns)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_non_equal_nulls():
+    # We want to make sure the relevant NaNs do not get dropped
+    # even if the entire row or column are NaNs
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+        columns=["col1", "col2", "col3"],
+    )
+    df2 = df.copy()
+    df2.loc[0, "col1"] = "c"
+    df2.loc[2, "col3"] = np.nan
+
+    result = df.compare(df2)
+
+    indices = pd.Index([0, 2])
+    columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+    expected = pd.DataFrame(
+        [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, np.nan]],
+        index=indices,
+        columns=columns,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("align_axis", [0, 1])
+def test_compare_multi_index(align_axis):
+    df = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]}
+    )
+    df.columns = pd.MultiIndex.from_arrays([["a", "a", "b"], ["col1", "col2", "col3"]])
+    df.index = pd.MultiIndex.from_arrays([["x", "x", "y"], [0, 1, 2]])
+
+    df2 = df.copy()
+    df2.iloc[0, 0] = "c"
+    df2.iloc[2, 2] = 4.0
+
+    result = df.compare(df2, align_axis=align_axis)
+
+    if align_axis == 0:
+        indices = pd.MultiIndex.from_arrays(
+            [["x", "x", "y", "y"], [0, 0, 2, 2], ["self", "other", "self", "other"]]
+        )
+        columns = pd.MultiIndex.from_arrays([["a", "b"], ["col1", "col3"]])
+        data = [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]]
+    else:
+        indices = pd.MultiIndex.from_arrays([["x", "y"], [0, 2]])
+        columns = pd.MultiIndex.from_arrays(
+            [
+                ["a", "a", "b", "b"],
+                ["col1", "col1", "col3", "col3"],
+                ["self", "other", "self", "other"],
+            ]
+        )
+        data = [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]]
+
+    expected = pd.DataFrame(data=data, index=indices, columns=columns)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_unaligned_objects():
+    # test DataFrames with different indices
+    msg = (
+        r"Can only compare identically-labeled \(both index and columns\) DataFrame "
+        "objects"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df1 = pd.DataFrame([1, 2, 3], index=["a", "b", "c"])
+        df2 = pd.DataFrame([1, 2, 3], index=["a", "b", "d"])
+        df1.compare(df2)
+
+    # test DataFrames with different shapes
+    msg = (
+        r"Can only compare identically-labeled \(both index and columns\) DataFrame "
+        "objects"
+    )
+    with pytest.raises(ValueError, match=msg):
+        df1 = pd.DataFrame(np.ones((3, 3)))
+        df2 = pd.DataFrame(np.zeros((2, 1)))
+        df1.compare(df2)
+
+
+def test_compare_result_names():
+    # GH 44354
+    df1 = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+    )
+    df2 = pd.DataFrame(
+        {
+            "col1": ["c", "b", "c"],
+            "col2": [1.0, 2.0, np.nan],
+            "col3": [1.0, 2.0, np.nan],
+        },
+    )
+    result = df1.compare(df2, result_names=("left", "right"))
+    expected = pd.DataFrame(
+        {
+            ("col1", "left"): {0: "a", 2: np.nan},
+            ("col1", "right"): {0: "c", 2: np.nan},
+            ("col3", "left"): {0: np.nan, 2: 3.0},
+            ("col3", "right"): {0: np.nan, 2: np.nan},
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "result_names",
+    [
+        [1, 2],
+        "HK",
+        {"2": 2, "3": 3},
+        3,
+        3.0,
+    ],
+)
+def test_invalid_input_result_names(result_names):
+    # GH 44354
+    df1 = pd.DataFrame(
+        {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+    )
+    df2 = pd.DataFrame(
+        {
+            "col1": ["c", "b", "c"],
+            "col2": [1.0, 2.0, np.nan],
+            "col3": [1.0, 2.0, np.nan],
+        },
+    )
+    with pytest.raises(
+        TypeError,
+        match=(
+            f"Passing 'result_names' as a {type(result_names)} is not "
+            "supported. Provide 'result_names' as a tuple instead."
+        ),
+    ):
+        df1.compare(df2, result_names=result_names)
+
+
+@pytest.mark.parametrize(
+    "val1,val2",
+    [(4, pd.NA), (pd.NA, pd.NA), (pd.NA, 4)],
+)
+def test_compare_ea_and_np_dtype(val1, val2):
+    # GH 48966
+    arr = [4.0, val1]
+    ser = pd.Series([1, val2], dtype="Int64")
+
+    df1 = pd.DataFrame({"a": arr, "b": [1.0, 2]})
+    df2 = pd.DataFrame({"a": ser, "b": [1.0, 2]})
+    expected = pd.DataFrame(
+        {
+            ("a", "self"): arr,
+            ("a", "other"): ser,
+            ("b", "self"): np.nan,
+            ("b", "other"): np.nan,
+        }
+    )
+    if val1 is pd.NA and val2 is pd.NA:
+        # GH#18463 TODO: is this really the desired behavior?
+        expected.loc[1, ("a", "self")] = np.nan
+
+    if val1 is pd.NA and np_version_gte1p25:
+        # can't compare with numpy array if it contains pd.NA
+        with pytest.raises(TypeError, match="boolean value of NA is ambiguous"):
+            result = df1.compare(df2, keep_shape=True)
+    else:
+        result = df1.compare(df2, keep_shape=True)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df1_val,df2_val,diff_self,diff_other",
+    [
+        (4, 3, 4, 3),
+        (4, 4, pd.NA, pd.NA),
+        (4, pd.NA, 4, pd.NA),
+        (pd.NA, pd.NA, pd.NA, pd.NA),
+    ],
+)
+def test_compare_nullable_int64_dtype(df1_val, df2_val, diff_self, diff_other):
+    # GH 48966
+    df1 = pd.DataFrame({"a": pd.Series([df1_val, pd.NA], dtype="Int64"), "b": [1.0, 2]})
+    df2 = df1.copy()
+    df2.loc[0, "a"] = df2_val
+
+    expected = pd.DataFrame(
+        {
+            ("a", "self"): pd.Series([diff_self, pd.NA], dtype="Int64"),
+            ("a", "other"): pd.Series([diff_other, pd.NA], dtype="Int64"),
+            ("b", "self"): np.nan,
+            ("b", "other"): np.nan,
+        }
+    )
+    result = df1.compare(df2, keep_shape=True)
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_convert_dtypes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_convert_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2b1016e88402903315767f63607aae25c936c68
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_convert_dtypes.py
@@ -0,0 +1,177 @@
+import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestConvertDtypes:
+    @pytest.mark.parametrize(
+        "convert_integer, expected", [(False, np.dtype("int32")), (True, "Int32")]
+    )
+    def test_convert_dtypes(self, convert_integer, expected, string_storage):
+        # Specific types are tested in tests/series/test_dtypes.py
+        # Just check that it works for DataFrame here
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
+                "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
+            }
+        )
+        with pd.option_context("string_storage", string_storage):
+            result = df.convert_dtypes(True, True, convert_integer, False)
+        expected = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype=expected),
+                "b": pd.Series(["x", "y", "z"], dtype=f"string[{string_storage}]"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_convert_empty(self):
+        # Empty DataFrame can pass convert_dtypes, see GH#40393
+        empty_df = pd.DataFrame()
+        tm.assert_frame_equal(empty_df, empty_df.convert_dtypes())
+
+    def test_convert_dtypes_retain_column_names(self):
+        # GH#41435
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+        df.columns.name = "cols"
+
+        result = df.convert_dtypes()
+        tm.assert_index_equal(result.columns, df.columns)
+        assert result.columns.name == "cols"
+
+    def test_pyarrow_dtype_backend(self):
+        pa = pytest.importorskip("pyarrow")
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
+                "b": pd.Series(["x", "y", None], dtype=np.dtype("O")),
+                "c": pd.Series([True, False, None], dtype=np.dtype("O")),
+                "d": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
+                "e": pd.Series(pd.date_range("2022", periods=3)),
+                "f": pd.Series(pd.date_range("2022", periods=3, tz="UTC").as_unit("s")),
+                "g": pd.Series(pd.timedelta_range("1D", periods=3)),
+            }
+        )
+        result = df.convert_dtypes(dtype_backend="pyarrow")
+        expected = pd.DataFrame(
+            {
+                "a": pd.arrays.ArrowExtensionArray(
+                    pa.array([1, 2, 3], type=pa.int32())
+                ),
+                "b": pd.arrays.ArrowExtensionArray(pa.array(["x", "y", None])),
+                "c": pd.arrays.ArrowExtensionArray(pa.array([True, False, None])),
+                "d": pd.arrays.ArrowExtensionArray(pa.array([None, 100.5, 200.0])),
+                "e": pd.arrays.ArrowExtensionArray(
+                    pa.array(
+                        [
+                            datetime.datetime(2022, 1, 1),
+                            datetime.datetime(2022, 1, 2),
+                            datetime.datetime(2022, 1, 3),
+                        ],
+                        type=pa.timestamp(unit="ns"),
+                    )
+                ),
+                "f": pd.arrays.ArrowExtensionArray(
+                    pa.array(
+                        [
+                            datetime.datetime(2022, 1, 1),
+                            datetime.datetime(2022, 1, 2),
+                            datetime.datetime(2022, 1, 3),
+                        ],
+                        type=pa.timestamp(unit="s", tz="UTC"),
+                    )
+                ),
+                "g": pd.arrays.ArrowExtensionArray(
+                    pa.array(
+                        [
+                            datetime.timedelta(1),
+                            datetime.timedelta(2),
+                            datetime.timedelta(3),
+                        ],
+                        type=pa.duration("ns"),
+                    )
+                ),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_pyarrow_dtype_backend_already_pyarrow(self):
+        pytest.importorskip("pyarrow")
+        expected = pd.DataFrame([1, 2, 3], dtype="int64[pyarrow]")
+        result = expected.convert_dtypes(dtype_backend="pyarrow")
+        tm.assert_frame_equal(result, expected)
+
+    def test_pyarrow_dtype_backend_from_pandas_nullable(self):
+        pa = pytest.importorskip("pyarrow")
+        df = pd.DataFrame(
+            {
+                "a": pd.Series([1, 2, None], dtype="Int32"),
+                "b": pd.Series(["x", "y", None], dtype="string[python]"),
+                "c": pd.Series([True, False, None], dtype="boolean"),
+                "d": pd.Series([None, 100.5, 200], dtype="Float64"),
+            }
+        )
+        result = df.convert_dtypes(dtype_backend="pyarrow")
+        expected = pd.DataFrame(
+            {
+                "a": pd.arrays.ArrowExtensionArray(
+                    pa.array([1, 2, None], type=pa.int32())
+                ),
+                "b": pd.arrays.ArrowExtensionArray(pa.array(["x", "y", None])),
+                "c": pd.arrays.ArrowExtensionArray(pa.array([True, False, None])),
+                "d": pd.arrays.ArrowExtensionArray(pa.array([None, 100.5, 200.0])),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_pyarrow_dtype_empty_object(self):
+        # GH 50970
+        pytest.importorskip("pyarrow")
+        expected = pd.DataFrame(columns=[0])
+        result = expected.convert_dtypes(dtype_backend="pyarrow")
+        tm.assert_frame_equal(result, expected)
+
+    def test_pyarrow_engine_lines_false(self):
+        # GH 48893
+        df = pd.DataFrame({"a": [1, 2, 3]})
+        msg = (
+            "dtype_backend numpy is invalid, only 'numpy_nullable' and "
+            "'pyarrow' are allowed."
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.convert_dtypes(dtype_backend="numpy")
+
+    def test_pyarrow_backend_no_conversion(self):
+        # GH#52872
+        pytest.importorskip("pyarrow")
+        df = pd.DataFrame({"a": [1, 2], "b": 1.5, "c": True, "d": "x"})
+        expected = df.copy()
+        result = df.convert_dtypes(
+            convert_floating=False,
+            convert_integer=False,
+            convert_boolean=False,
+            convert_string=False,
+            dtype_backend="pyarrow",
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_convert_dtypes_pyarrow_to_np_nullable(self):
+        # GH 53648
+        pytest.importorskip("pyarrow")
+        ser = pd.DataFrame(range(2), dtype="int32[pyarrow]")
+        result = ser.convert_dtypes(dtype_backend="numpy_nullable")
+        expected = pd.DataFrame(range(2), dtype="Int32")
+        tm.assert_frame_equal(result, expected)
+
+    def test_convert_dtypes_pyarrow_timestamp(self):
+        # GH 54191
+        pytest.importorskip("pyarrow")
+        ser = pd.Series(pd.date_range("2020-01-01", "2020-01-02", freq="1min"))
+        expected = ser.astype("timestamp[ms][pyarrow]")
+        result = expected.convert_dtypes(dtype_backend="pyarrow")
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_copy.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..95fcaaa473067bad7cd04a84c02fb10be661fb7d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_copy.py
@@ -0,0 +1,64 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestCopy:
+    @pytest.mark.parametrize("attr", ["index", "columns"])
+    def test_copy_index_name_checking(self, float_frame, attr):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
+        ind = getattr(float_frame, attr)
+        ind.name = None
+        cp = float_frame.copy()
+        getattr(cp, attr).name = "foo"
+        assert getattr(float_frame, attr).name is None
+
+    @td.skip_copy_on_write_invalid_test
+    def test_copy_cache(self):
+        # GH#31784 _item_cache not cleared on copy causes incorrect reads after updates
+        df = DataFrame({"a": [1]})
+
+        df["x"] = [0]
+        df["a"]
+
+        df.copy()
+
+        df["a"].values[0] = -1
+
+        tm.assert_frame_equal(df, DataFrame({"a": [-1], "x": [0]}))
+
+        df["y"] = [0]
+
+        assert df["a"].values[0] == -1
+        tm.assert_frame_equal(df, DataFrame({"a": [-1], "x": [0], "y": [0]}))
+
+    def test_copy(self, float_frame, float_string_frame):
+        cop = float_frame.copy()
+        cop["E"] = cop["A"]
+        assert "E" not in float_frame
+
+        # copy objects
+        copy = float_string_frame.copy()
+        assert copy._mgr is not float_string_frame._mgr
+
+    @td.skip_array_manager_invalid_test
+    def test_copy_consolidates(self):
+        # GH#42477
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).integers(0, 100, size=55),
+                "b": np.random.default_rng(2).integers(0, 100, size=55),
+            }
+        )
+
+        for i in range(0, 10):
+            df.loc[:, f"n_{i}"] = np.random.default_rng(2).integers(0, 100, size=55)
+
+        assert len(df._mgr.blocks) == 11
+        result = df.copy()
+        assert len(result._mgr.blocks) == 1
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_count.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_count.py
new file mode 100644
index 0000000000000000000000000000000000000000..1553a8a86305dd931c5378245daf272472d41b20
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_count.py
@@ -0,0 +1,39 @@
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameCount:
+    def test_count(self):
+        # corner case
+        frame = DataFrame()
+        ct1 = frame.count(1)
+        assert isinstance(ct1, Series)
+
+        ct2 = frame.count(0)
+        assert isinstance(ct2, Series)
+
+        # GH#423
+        df = DataFrame(index=range(10))
+        result = df.count(1)
+        expected = Series(0, index=df.index)
+        tm.assert_series_equal(result, expected)
+
+        df = DataFrame(columns=range(10))
+        result = df.count(0)
+        expected = Series(0, index=df.columns)
+        tm.assert_series_equal(result, expected)
+
+        df = DataFrame()
+        result = df.count()
+        expected = Series(dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+    def test_count_objects(self, float_string_frame):
+        dm = DataFrame(float_string_frame._series)
+        df = DataFrame(float_string_frame._series)
+
+        tm.assert_series_equal(dm.count(), df.count())
+        tm.assert_series_equal(dm.count(1), df.count(1))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_cov_corr.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_cov_corr.py
new file mode 100644
index 0000000000000000000000000000000000000000..23a9656193d2ccaf3ad64824510d60223ca9e6a9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_cov_corr.py
@@ -0,0 +1,458 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    isna,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameCov:
+    def test_cov(self, float_frame, float_string_frame):
+        # min_periods no NAs (corner case)
+        expected = float_frame.cov()
+        result = float_frame.cov(min_periods=len(float_frame))
+
+        tm.assert_frame_equal(expected, result)
+
+        result = float_frame.cov(min_periods=len(float_frame) + 1)
+        assert isna(result.values).all()
+
+        # with NAs
+        frame = float_frame.copy()
+        frame.iloc[:5, frame.columns.get_loc("A")] = np.nan
+        frame.iloc[5:10, frame.columns.get_loc("B")] = np.nan
+        result = frame.cov(min_periods=len(frame) - 8)
+        expected = frame.cov()
+        expected.loc["A", "B"] = np.nan
+        expected.loc["B", "A"] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+        # regular
+        result = frame.cov()
+        expected = frame["A"].cov(frame["C"])
+        tm.assert_almost_equal(result["A"]["C"], expected)
+
+        # fails on non-numeric types
+        with pytest.raises(ValueError, match="could not convert string to float"):
+            float_string_frame.cov()
+        result = float_string_frame.cov(numeric_only=True)
+        expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].cov()
+        tm.assert_frame_equal(result, expected)
+
+        # Single column frame
+        df = DataFrame(np.linspace(0.0, 1.0, 10))
+        result = df.cov()
+        expected = DataFrame(
+            np.cov(df.values.T).reshape((1, 1)), index=df.columns, columns=df.columns
+        )
+        tm.assert_frame_equal(result, expected)
+        df.loc[0] = np.nan
+        result = df.cov()
+        expected = DataFrame(
+            np.cov(df.values[1:].T).reshape((1, 1)),
+            index=df.columns,
+            columns=df.columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("test_ddof", [None, 0, 1, 2, 3])
+    def test_cov_ddof(self, test_ddof):
+        # GH#34611
+        np_array1 = np.random.default_rng(2).random(10)
+        np_array2 = np.random.default_rng(2).random(10)
+        df = DataFrame({0: np_array1, 1: np_array2})
+        result = df.cov(ddof=test_ddof)
+        expected_np = np.cov(np_array1, np_array2, ddof=test_ddof)
+        expected = DataFrame(expected_np)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "other_column", [pd.array([1, 2, 3]), np.array([1.0, 2.0, 3.0])]
+    )
+    def test_cov_nullable_integer(self, other_column):
+        # https://github.com/pandas-dev/pandas/issues/33803
+        data = DataFrame({"a": pd.array([1, 2, None]), "b": other_column})
+        result = data.cov()
+        arr = np.array([[0.5, 0.5], [0.5, 1.0]])
+        expected = DataFrame(arr, columns=["a", "b"], index=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_cov_numeric_only(self, numeric_only):
+        # when dtypes of pandas series are different
+        # then ndarray will have dtype=object,
+        # so it need to be properly handled
+        df = DataFrame({"a": [1, 0], "c": ["x", "y"]})
+        expected = DataFrame(0.5, index=["a"], columns=["a"])
+        if numeric_only:
+            result = df.cov(numeric_only=numeric_only)
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(ValueError, match="could not convert string to float"):
+                df.cov(numeric_only=numeric_only)
+
+
+class TestDataFrameCorr:
+    # DataFrame.corr(), as opposed to DataFrame.corrwith
+
+    @pytest.mark.parametrize("method", ["pearson", "kendall", "spearman"])
+    def test_corr_scipy_method(self, float_frame, method):
+        pytest.importorskip("scipy")
+        float_frame.loc[float_frame.index[:5], "A"] = np.nan
+        float_frame.loc[float_frame.index[5:10], "B"] = np.nan
+        float_frame.loc[float_frame.index[:10], "A"] = float_frame["A"][10:20]
+
+        correls = float_frame.corr(method=method)
+        expected = float_frame["A"].corr(float_frame["C"], method=method)
+        tm.assert_almost_equal(correls["A"]["C"], expected)
+
+    # ---------------------------------------------------------------------
+
+    def test_corr_non_numeric(self, float_string_frame):
+        with pytest.raises(ValueError, match="could not convert string to float"):
+            float_string_frame.corr()
+        result = float_string_frame.corr(numeric_only=True)
+        expected = float_string_frame.loc[:, ["A", "B", "C", "D"]].corr()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("meth", ["pearson", "kendall", "spearman"])
+    def test_corr_nooverlap(self, meth):
+        # nothing in common
+        pytest.importorskip("scipy")
+        df = DataFrame(
+            {
+                "A": [1, 1.5, 1, np.nan, np.nan, np.nan],
+                "B": [np.nan, np.nan, np.nan, 1, 1.5, 1],
+                "C": [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+            }
+        )
+        rs = df.corr(meth)
+        assert isna(rs.loc["A", "B"])
+        assert isna(rs.loc["B", "A"])
+        assert rs.loc["A", "A"] == 1
+        assert rs.loc["B", "B"] == 1
+        assert isna(rs.loc["C", "C"])
+
+    @pytest.mark.parametrize("meth", ["pearson", "spearman"])
+    def test_corr_constant(self, meth):
+        # constant --> all NA
+        df = DataFrame(
+            {
+                "A": [1, 1, 1, np.nan, np.nan, np.nan],
+                "B": [np.nan, np.nan, np.nan, 1, 1, 1],
+            }
+        )
+        rs = df.corr(meth)
+        assert isna(rs.values).all()
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    @pytest.mark.parametrize("meth", ["pearson", "kendall", "spearman"])
+    def test_corr_int_and_boolean(self, meth):
+        # when dtypes of pandas series are different
+        # then ndarray will have dtype=object,
+        # so it need to be properly handled
+        pytest.importorskip("scipy")
+        df = DataFrame({"a": [True, False], "b": [1, 0]})
+
+        expected = DataFrame(np.ones((2, 2)), index=["a", "b"], columns=["a", "b"])
+        result = df.corr(meth)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("method", ["cov", "corr"])
+    def test_corr_cov_independent_index_column(self, method):
+        # GH#14617
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal(4 * 10).reshape(10, 4),
+            columns=list("abcd"),
+        )
+        result = getattr(df, method)()
+        assert result.index is not result.columns
+        assert result.index.equals(result.columns)
+
+    def test_corr_invalid_method(self):
+        # GH#22298
+        df = DataFrame(np.random.default_rng(2).normal(size=(10, 2)))
+        msg = "method must be either 'pearson', 'spearman', 'kendall', or a callable, "
+        with pytest.raises(ValueError, match=msg):
+            df.corr(method="____")
+
+    def test_corr_int(self):
+        # dtypes other than float64 GH#1761
+        df = DataFrame({"a": [1, 2, 3, 4], "b": [1, 2, 3, 4]})
+
+        df.cov()
+        df.corr()
+
+    @pytest.mark.parametrize(
+        "nullable_column", [pd.array([1, 2, 3]), pd.array([1, 2, None])]
+    )
+    @pytest.mark.parametrize(
+        "other_column",
+        [pd.array([1, 2, 3]), np.array([1.0, 2.0, 3.0]), np.array([1.0, 2.0, np.nan])],
+    )
+    @pytest.mark.parametrize("method", ["pearson", "spearman", "kendall"])
+    def test_corr_nullable_integer(self, nullable_column, other_column, method):
+        # https://github.com/pandas-dev/pandas/issues/33803
+        pytest.importorskip("scipy")
+        data = DataFrame({"a": nullable_column, "b": other_column})
+        result = data.corr(method=method)
+        expected = DataFrame(np.ones((2, 2)), columns=["a", "b"], index=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_corr_item_cache(self, using_copy_on_write):
+        # Check that corr does not lead to incorrect entries in item_cache
+
+        df = DataFrame({"A": range(10)})
+        df["B"] = range(10)[::-1]
+
+        ser = df["A"]  # populate item_cache
+        assert len(df._mgr.arrays) == 2  # i.e. 2 blocks
+
+        _ = df.corr(numeric_only=True)
+
+        if using_copy_on_write:
+            ser.iloc[0] = 99
+            assert df.loc[0, "A"] == 0
+        else:
+            # Check that the corr didn't break link between ser and df
+            ser.values[0] = 99
+            assert df.loc[0, "A"] == 99
+            assert df["A"] is ser
+            assert df.values[0, 0] == 99
+
+    @pytest.mark.parametrize("length", [2, 20, 200, 2000])
+    def test_corr_for_constant_columns(self, length):
+        # GH: 37448
+        df = DataFrame(length * [[0.4, 0.1]], columns=["A", "B"])
+        result = df.corr()
+        expected = DataFrame(
+            {"A": [np.nan, np.nan], "B": [np.nan, np.nan]}, index=["A", "B"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_calc_corr_small_numbers(self):
+        # GH: 37452
+        df = DataFrame(
+            {"A": [1.0e-20, 2.0e-20, 3.0e-20], "B": [1.0e-20, 2.0e-20, 3.0e-20]}
+        )
+        result = df.corr()
+        expected = DataFrame({"A": [1.0, 1.0], "B": [1.0, 1.0]}, index=["A", "B"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("method", ["pearson", "spearman", "kendall"])
+    def test_corr_min_periods_greater_than_length(self, method):
+        pytest.importorskip("scipy")
+        df = DataFrame({"A": [1, 2], "B": [1, 2]})
+        result = df.corr(method=method, min_periods=3)
+        expected = DataFrame(
+            {"A": [np.nan, np.nan], "B": [np.nan, np.nan]}, index=["A", "B"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("meth", ["pearson", "kendall", "spearman"])
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_corr_numeric_only(self, meth, numeric_only):
+        # when dtypes of pandas series are different
+        # then ndarray will have dtype=object,
+        # so it need to be properly handled
+        pytest.importorskip("scipy")
+        df = DataFrame({"a": [1, 0], "b": [1, 0], "c": ["x", "y"]})
+        expected = DataFrame(np.ones((2, 2)), index=["a", "b"], columns=["a", "b"])
+        if numeric_only:
+            result = df.corr(meth, numeric_only=numeric_only)
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(ValueError, match="could not convert string to float"):
+                df.corr(meth, numeric_only=numeric_only)
+
+
+class TestDataFrameCorrWith:
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "float64",
+            "Float64",
+            pytest.param("float64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+        ],
+    )
+    def test_corrwith(self, datetime_frame, dtype):
+        datetime_frame = datetime_frame.astype(dtype)
+
+        a = datetime_frame
+        noise = Series(np.random.default_rng(2).standard_normal(len(a)), index=a.index)
+
+        b = datetime_frame.add(noise, axis=0)
+
+        # make sure order does not matter
+        b = b.reindex(columns=b.columns[::-1], index=b.index[::-1][10:])
+        del b["B"]
+
+        colcorr = a.corrwith(b, axis=0)
+        tm.assert_almost_equal(colcorr["A"], a["A"].corr(b["A"]))
+
+        rowcorr = a.corrwith(b, axis=1)
+        tm.assert_series_equal(rowcorr, a.T.corrwith(b.T, axis=0))
+
+        dropped = a.corrwith(b, axis=0, drop=True)
+        tm.assert_almost_equal(dropped["A"], a["A"].corr(b["A"]))
+        assert "B" not in dropped
+
+        dropped = a.corrwith(b, axis=1, drop=True)
+        assert a.index[-1] not in dropped.index
+
+        # non time-series data
+        index = ["a", "b", "c", "d", "e"]
+        columns = ["one", "two", "three", "four"]
+        df1 = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 4)),
+            index=index,
+            columns=columns,
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            index=index[:4],
+            columns=columns,
+        )
+        correls = df1.corrwith(df2, axis=1)
+        for row in index[:4]:
+            tm.assert_almost_equal(correls[row], df1.loc[row].corr(df2.loc[row]))
+
+    def test_corrwith_with_objects(self):
+        df1 = tm.makeTimeDataFrame()
+        df2 = tm.makeTimeDataFrame()
+        cols = ["A", "B", "C", "D"]
+
+        df1["obj"] = "foo"
+        df2["obj"] = "bar"
+
+        with pytest.raises(TypeError, match="Could not convert"):
+            df1.corrwith(df2)
+        result = df1.corrwith(df2, numeric_only=True)
+        expected = df1.loc[:, cols].corrwith(df2.loc[:, cols])
+        tm.assert_series_equal(result, expected)
+
+        with pytest.raises(TypeError, match="unsupported operand type"):
+            df1.corrwith(df2, axis=1)
+        result = df1.corrwith(df2, axis=1, numeric_only=True)
+        expected = df1.loc[:, cols].corrwith(df2.loc[:, cols], axis=1)
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_series(self, datetime_frame):
+        result = datetime_frame.corrwith(datetime_frame["A"])
+        expected = datetime_frame.apply(datetime_frame["A"].corr)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_matches_corrcoef(self):
+        df1 = DataFrame(np.arange(10000), columns=["a"])
+        df2 = DataFrame(np.arange(10000) ** 2, columns=["a"])
+        c1 = df1.corrwith(df2)["a"]
+        c2 = np.corrcoef(df1["a"], df2["a"])[0][1]
+
+        tm.assert_almost_equal(c1, c2)
+        assert c1 < 1
+
+    @pytest.mark.parametrize("numeric_only", [True, False])
+    def test_corrwith_mixed_dtypes(self, numeric_only):
+        # GH#18570
+        df = DataFrame(
+            {"a": [1, 4, 3, 2], "b": [4, 6, 7, 3], "c": ["a", "b", "c", "d"]}
+        )
+        s = Series([0, 6, 7, 3])
+        if numeric_only:
+            result = df.corrwith(s, numeric_only=numeric_only)
+            corrs = [df["a"].corr(s), df["b"].corr(s)]
+            expected = Series(data=corrs, index=["a", "b"])
+            tm.assert_series_equal(result, expected)
+        else:
+            with pytest.raises(
+                ValueError,
+                match="could not convert string to float",
+            ):
+                df.corrwith(s, numeric_only=numeric_only)
+
+    def test_corrwith_index_intersection(self):
+        df1 = DataFrame(
+            np.random.default_rng(2).random(size=(10, 2)), columns=["a", "b"]
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).random(size=(10, 3)), columns=["a", "b", "c"]
+        )
+
+        result = df1.corrwith(df2, drop=True).index.sort_values()
+        expected = df1.columns.intersection(df2.columns).sort_values()
+        tm.assert_index_equal(result, expected)
+
+    def test_corrwith_index_union(self):
+        df1 = DataFrame(
+            np.random.default_rng(2).random(size=(10, 2)), columns=["a", "b"]
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).random(size=(10, 3)), columns=["a", "b", "c"]
+        )
+
+        result = df1.corrwith(df2, drop=False).index.sort_values()
+        expected = df1.columns.union(df2.columns).sort_values()
+        tm.assert_index_equal(result, expected)
+
+    def test_corrwith_dup_cols(self):
+        # GH#21925
+        df1 = DataFrame(np.vstack([np.arange(10)] * 3).T)
+        df2 = df1.copy()
+        df2 = pd.concat((df2, df2[0]), axis=1)
+
+        result = df1.corrwith(df2)
+        expected = Series(np.ones(4), index=[0, 0, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_corr_numerical_instabilities(self):
+        # GH#45640
+        df = DataFrame([[0.2, 0.4], [0.4, 0.2]])
+        result = df.corr()
+        expected = DataFrame({0: [1.0, -1.0], 1: [-1.0, 1.0]})
+        tm.assert_frame_equal(result - 1, expected - 1, atol=1e-17)
+
+    def test_corrwith_spearman(self):
+        # GH#21925
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).random(size=(100, 3)))
+        result = df.corrwith(df**2, method="spearman")
+        expected = Series(np.ones(len(result)))
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_kendall(self):
+        # GH#21925
+        pytest.importorskip("scipy")
+        df = DataFrame(np.random.default_rng(2).random(size=(100, 3)))
+        result = df.corrwith(df**2, method="kendall")
+        expected = Series(np.ones(len(result)))
+        tm.assert_series_equal(result, expected)
+
+    def test_corrwith_spearman_with_tied_data(self):
+        # GH#48826
+        pytest.importorskip("scipy")
+        df1 = DataFrame(
+            {
+                "A": [1, np.nan, 7, 8],
+                "B": [False, True, True, False],
+                "C": [10, 4, 9, 3],
+            }
+        )
+        df2 = df1[["B", "C"]]
+        result = (df1 + 1).corrwith(df2.B, method="spearman")
+        expected = Series([0.0, 1.0, 0.0], index=["A", "B", "C"])
+        tm.assert_series_equal(result, expected)
+
+        df_bool = DataFrame(
+            {"A": [True, True, False, False], "B": [True, False, False, True]}
+        )
+        ser_bool = Series([True, True, False, True])
+        result = df_bool.corrwith(ser_bool)
+        expected = Series([0.57735, 0.57735], index=["A", "B"])
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_describe.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_describe.py
new file mode 100644
index 0000000000000000000000000000000000000000..f56a7896c753ee506140d8d8bc7347c25b41fc5e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_describe.py
@@ -0,0 +1,417 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameDescribe:
+    def test_describe_bool_in_mixed_frame(self):
+        df = DataFrame(
+            {
+                "string_data": ["a", "b", "c", "d", "e"],
+                "bool_data": [True, True, False, False, False],
+                "int_data": [10, 20, 30, 40, 50],
+            }
+        )
+
+        # Integer data are included in .describe() output,
+        # Boolean and string data are not.
+        result = df.describe()
+        expected = DataFrame(
+            {"int_data": [5, 30, df.int_data.std(), 10, 20, 30, 40, 50]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # Top value is a boolean value that is False
+        result = df.describe(include=["bool"])
+
+        expected = DataFrame(
+            {"bool_data": [5, 2, False, 3]}, index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_empty_object(self):
+        # GH#27183
+        df = DataFrame({"A": [None, None]}, dtype=object)
+        result = df.describe()
+        expected = DataFrame(
+            {"A": [0, 0, np.nan, np.nan]},
+            dtype=object,
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.iloc[:0].describe()
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_bool_frame(self):
+        # GH#13891
+        df = DataFrame(
+            {
+                "bool_data_1": [False, False, True, True],
+                "bool_data_2": [False, True, True, True],
+            }
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"bool_data_1": [4, 2, False, 2], "bool_data_2": [4, 2, True, 3]},
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            {
+                "bool_data": [False, False, True, True, False],
+                "int_data": [0, 1, 2, 3, 4],
+            }
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"int_data": [5, 2, df.int_data.std(), 0, 1, 2, 3, 4]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            {"bool_data": [False, False, True, True], "str_data": ["a", "b", "c", "a"]}
+        )
+        result = df.describe()
+        expected = DataFrame(
+            {"bool_data": [4, 2, False, 2], "str_data": [4, 3, "a", 2]},
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_categorical(self):
+        df = DataFrame({"value": np.random.default_rng(2).integers(0, 10000, 100)})
+        labels = [f"{i} - {i + 499}" for i in range(0, 10000, 500)]
+        cat_labels = Categorical(labels, labels)
+
+        df = df.sort_values(by=["value"], ascending=True)
+        df["value_group"] = pd.cut(
+            df.value, range(0, 10500, 500), right=False, labels=cat_labels
+        )
+        cat = df
+
+        # Categoricals should not show up together with numerical columns
+        result = cat.describe()
+        assert len(result.columns) == 1
+
+        # In a frame, describe() for the cat should be the same as for string
+        # arrays (count, unique, top, freq)
+
+        cat = Categorical(
+            ["a", "b", "b", "b"], categories=["a", "b", "c"], ordered=True
+        )
+        s = Series(cat)
+        result = s.describe()
+        expected = Series([4, 2, "b", 3], index=["count", "unique", "top", "freq"])
+        tm.assert_series_equal(result, expected)
+
+        cat = Series(Categorical(["a", "b", "c", "c"]))
+        df3 = DataFrame({"cat": cat, "s": ["a", "b", "c", "c"]})
+        result = df3.describe()
+        tm.assert_numpy_array_equal(result["cat"].values, result["s"].values)
+
+    def test_describe_empty_categorical_column(self):
+        # GH#26397
+        # Ensure the index of an empty categorical DataFrame column
+        # also contains (count, unique, top, freq)
+        df = DataFrame({"empty_col": Categorical([])})
+        result = df.describe()
+        expected = DataFrame(
+            {"empty_col": [0, 0, np.nan, np.nan]},
+            index=["count", "unique", "top", "freq"],
+            dtype="object",
+        )
+        tm.assert_frame_equal(result, expected)
+        # ensure NaN, not None
+        assert np.isnan(result.iloc[2, 0])
+        assert np.isnan(result.iloc[3, 0])
+
+    def test_describe_categorical_columns(self):
+        # GH#11558
+        columns = pd.CategoricalIndex(["int1", "int2", "obj"], ordered=True, name="XXX")
+        df = DataFrame(
+            {
+                "int1": [10, 20, 30, 40, 50],
+                "int2": [10, 20, 30, 40, 50],
+                "obj": ["A", 0, None, "X", 1],
+            },
+            columns=columns,
+        )
+        result = df.describe()
+
+        exp_columns = pd.CategoricalIndex(
+            ["int1", "int2"],
+            categories=["int1", "int2", "obj"],
+            ordered=True,
+            name="XXX",
+        )
+        expected = DataFrame(
+            {
+                "int1": [5, 30, df.int1.std(), 10, 20, 30, 40, 50],
+                "int2": [5, 30, df.int2.std(), 10, 20, 30, 40, 50],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            columns=exp_columns,
+        )
+
+        tm.assert_frame_equal(result, expected)
+        tm.assert_categorical_equal(result.columns.values, expected.columns.values)
+
+    def test_describe_datetime_columns(self):
+        columns = pd.DatetimeIndex(
+            ["2011-01-01", "2011-02-01", "2011-03-01"],
+            freq="MS",
+            tz="US/Eastern",
+            name="XXX",
+        )
+        df = DataFrame(
+            {
+                0: [10, 20, 30, 40, 50],
+                1: [10, 20, 30, 40, 50],
+                2: ["A", 0, None, "X", 1],
+            }
+        )
+        df.columns = columns
+        result = df.describe()
+
+        exp_columns = pd.DatetimeIndex(
+            ["2011-01-01", "2011-02-01"], freq="MS", tz="US/Eastern", name="XXX"
+        )
+        expected = DataFrame(
+            {
+                0: [5, 30, df.iloc[:, 0].std(), 10, 20, 30, 40, 50],
+                1: [5, 30, df.iloc[:, 1].std(), 10, 20, 30, 40, 50],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        expected.columns = exp_columns
+        tm.assert_frame_equal(result, expected)
+        assert result.columns.freq == "MS"
+        assert result.columns.tz == expected.columns.tz
+
+    def test_describe_timedelta_values(self):
+        # GH#6145
+        t1 = pd.timedelta_range("1 days", freq="D", periods=5)
+        t2 = pd.timedelta_range("1 hours", freq="H", periods=5)
+        df = DataFrame({"t1": t1, "t2": t2})
+
+        expected = DataFrame(
+            {
+                "t1": [
+                    5,
+                    pd.Timedelta("3 days"),
+                    df.iloc[:, 0].std(),
+                    pd.Timedelta("1 days"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("3 days"),
+                    pd.Timedelta("4 days"),
+                    pd.Timedelta("5 days"),
+                ],
+                "t2": [
+                    5,
+                    pd.Timedelta("3 hours"),
+                    df.iloc[:, 1].std(),
+                    pd.Timedelta("1 hours"),
+                    pd.Timedelta("2 hours"),
+                    pd.Timedelta("3 hours"),
+                    pd.Timedelta("4 hours"),
+                    pd.Timedelta("5 hours"),
+                ],
+            },
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+
+        result = df.describe()
+        tm.assert_frame_equal(result, expected)
+
+        exp_repr = (
+            "                              t1                         t2\n"
+            "count                          5                          5\n"
+            "mean             3 days 00:00:00            0 days 03:00:00\n"
+            "std    1 days 13:56:50.394919273  0 days 01:34:52.099788303\n"
+            "min              1 days 00:00:00            0 days 01:00:00\n"
+            "25%              2 days 00:00:00            0 days 02:00:00\n"
+            "50%              3 days 00:00:00            0 days 03:00:00\n"
+            "75%              4 days 00:00:00            0 days 04:00:00\n"
+            "max              5 days 00:00:00            0 days 05:00:00"
+        )
+        assert repr(result) == exp_repr
+
+    def test_describe_tz_values(self, tz_naive_fixture):
+        # GH#21332
+        tz = tz_naive_fixture
+        s1 = Series(range(5))
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s2 = Series(date_range(start, end, tz=tz))
+        df = DataFrame({"s1": s1, "s2": s2})
+
+        expected = DataFrame(
+            {
+                "s1": [5, 2, 0, 1, 2, 3, 4, 1.581139],
+                "s2": [
+                    5,
+                    Timestamp(2018, 1, 3).tz_localize(tz),
+                    start.tz_localize(tz),
+                    s2[1],
+                    s2[2],
+                    s2[3],
+                    end.tz_localize(tz),
+                    np.nan,
+                ],
+            },
+            index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
+        )
+        result = df.describe(include="all")
+        tm.assert_frame_equal(result, expected)
+
+    def test_datetime_is_numeric_includes_datetime(self):
+        df = DataFrame({"a": date_range("2012", periods=3), "b": [1, 2, 3]})
+        result = df.describe()
+        expected = DataFrame(
+            {
+                "a": [
+                    3,
+                    Timestamp("2012-01-02"),
+                    Timestamp("2012-01-01"),
+                    Timestamp("2012-01-01T12:00:00"),
+                    Timestamp("2012-01-02"),
+                    Timestamp("2012-01-02T12:00:00"),
+                    Timestamp("2012-01-03"),
+                    np.nan,
+                ],
+                "b": [3, 2, 1, 1.5, 2, 2.5, 3, 1],
+            },
+            index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_tz_values2(self):
+        tz = "CET"
+        s1 = Series(range(5))
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s2 = Series(date_range(start, end, tz=tz))
+        df = DataFrame({"s1": s1, "s2": s2})
+
+        s1_ = s1.describe()
+        s2_ = s2.describe()
+        idx = [
+            "count",
+            "mean",
+            "min",
+            "25%",
+            "50%",
+            "75%",
+            "max",
+            "std",
+        ]
+        expected = pd.concat([s1_, s2_], axis=1, keys=["s1", "s2"]).reindex(
+            idx, copy=False
+        )
+
+        result = df.describe(include="all")
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_percentiles_integer_idx(self):
+        # GH#26660
+        df = DataFrame({"x": [1]})
+        pct = np.linspace(0, 1, 10 + 1)
+        result = df.describe(percentiles=pct)
+
+        expected = DataFrame(
+            {"x": [1.0, 1.0, np.nan, 1.0, *(1.0 for _ in pct), 1.0]},
+            index=[
+                "count",
+                "mean",
+                "std",
+                "min",
+                "0%",
+                "10%",
+                "20%",
+                "30%",
+                "40%",
+                "50%",
+                "60%",
+                "70%",
+                "80%",
+                "90%",
+                "100%",
+                "max",
+            ],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_does_not_raise_error_for_dictlike_elements(self):
+        # GH#32409
+        df = DataFrame([{"test": {"a": "1"}}, {"test": {"a": "2"}}])
+        expected = DataFrame(
+            {"test": [2, 2, {"a": "1"}, 1]}, index=["count", "unique", "top", "freq"]
+        )
+        result = df.describe()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("exclude", ["x", "y", ["x", "y"], ["x", "z"]])
+    def test_describe_when_include_all_exclude_not_allowed(self, exclude):
+        """
+        When include is 'all', then setting exclude != None is not allowed.
+        """
+        df = DataFrame({"x": [1], "y": [2], "z": [3]})
+        msg = "exclude must be None when include is 'all'"
+        with pytest.raises(ValueError, match=msg):
+            df.describe(include="all", exclude=exclude)
+
+    def test_describe_with_duplicate_columns(self):
+        df = DataFrame(
+            [[1, 1, 1], [2, 2, 2], [3, 3, 3]],
+            columns=["bar", "a", "a"],
+            dtype="float64",
+        )
+        result = df.describe()
+        ser = df.iloc[:, 0].describe()
+        expected = pd.concat([ser, ser, ser], keys=df.columns, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_ea_with_na(self, any_numeric_ea_dtype):
+        # GH#48778
+
+        df = DataFrame({"a": [1, pd.NA, pd.NA], "b": pd.NA}, dtype=any_numeric_ea_dtype)
+        result = df.describe()
+        expected = DataFrame(
+            {"a": [1.0, 1.0, pd.NA] + [1.0] * 5, "b": [0.0] + [pd.NA] * 7},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype="Float64",
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_describe_exclude_pa_dtype(self):
+        # GH#52570
+        pa = pytest.importorskip("pyarrow")
+        df = DataFrame(
+            {
+                "a": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int8())),
+                "b": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int16())),
+                "c": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int32())),
+            }
+        )
+        result = df.describe(
+            include=pd.ArrowDtype(pa.int8()), exclude=pd.ArrowDtype(pa.int32())
+        )
+        expected = DataFrame(
+            {"a": [3, 2, 1, 1, 1.5, 2, 2.5, 3]},
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype=pd.ArrowDtype(pa.float64()),
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_diff.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..b401f182242b10c28754b25bae0ebc89caa069fa
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_diff.py
@@ -0,0 +1,304 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameDiff:
+    def test_diff_requires_integer(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((2, 2)))
+        with pytest.raises(ValueError, match="periods must be an integer"):
+            df.diff(1.5)
+
+    # GH#44572 np.int64 is accepted
+    @pytest.mark.parametrize("num", [1, np.int64(1)])
+    def test_diff(self, datetime_frame, num):
+        df = datetime_frame
+        the_diff = df.diff(num)
+
+        expected = df["A"] - df["A"].shift(num)
+        tm.assert_series_equal(the_diff["A"], expected)
+
+    def test_diff_int_dtype(self):
+        # int dtype
+        a = 10_000_000_000_000_000
+        b = a + 1
+        ser = Series([a, b])
+
+        rs = DataFrame({"s": ser}).diff()
+        assert rs.s[1] == 1
+
+    def test_diff_mixed_numeric(self, datetime_frame):
+        # mixed numeric
+        tf = datetime_frame.astype("float32")
+        the_diff = tf.diff(1)
+        tm.assert_series_equal(the_diff["A"], tf["A"] - tf["A"].shift(1))
+
+    def test_diff_axis1_nonconsolidated(self):
+        # GH#10907
+        df = DataFrame({"y": Series([2]), "z": Series([3])})
+        df.insert(0, "x", 1)
+        result = df.diff(axis=1)
+        expected = DataFrame({"x": np.nan, "y": Series(1), "z": Series(1)})
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_timedelta64_with_nat(self):
+        # GH#32441
+        arr = np.arange(6).reshape(3, 2).astype("timedelta64[ns]")
+        arr[:, 0] = np.timedelta64("NaT", "ns")
+
+        df = DataFrame(arr)
+        result = df.diff(1, axis=0)
+
+        expected = DataFrame({0: df[0], 1: [pd.NaT, pd.Timedelta(2), pd.Timedelta(2)]})
+        tm.assert_equal(result, expected)
+
+        result = df.diff(0)
+        expected = df - df
+        assert expected[0].isna().all()
+        tm.assert_equal(result, expected)
+
+        result = df.diff(-1, axis=1)
+        expected = df * np.nan
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis0_with_nat(self, tz):
+        # GH#32441
+        dti = pd.DatetimeIndex(["NaT", "2019-01-01", "2019-01-02"], tz=tz)
+        ser = Series(dti)
+
+        df = ser.to_frame()
+
+        result = df.diff()
+        ex_index = pd.TimedeltaIndex([pd.NaT, pd.NaT, pd.Timedelta(days=1)])
+        expected = Series(ex_index).to_frame()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_with_nat_zero_periods(self, tz):
+        # diff on NaT values should give NaT, not timedelta64(0)
+        dti = date_range("2016-01-01", periods=4, tz=tz)
+        ser = Series(dti)
+        df = ser.to_frame()
+
+        df[1] = ser.copy()
+
+        df.iloc[:, 0] = pd.NaT
+
+        expected = df - df
+        assert expected[0].isna().all()
+
+        result = df.diff(0, axis=0)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.diff(0, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis0(self, tz):
+        # GH#18578
+        df = DataFrame(
+            {
+                0: date_range("2010", freq="D", periods=2, tz=tz),
+                1: date_range("2010", freq="D", periods=2, tz=tz),
+            }
+        )
+
+        result = df.diff(axis=0)
+        expected = DataFrame(
+            {
+                0: pd.TimedeltaIndex(["NaT", "1 days"]),
+                1: pd.TimedeltaIndex(["NaT", "1 days"]),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis1(self, tz):
+        # GH#18578
+        df = DataFrame(
+            {
+                0: date_range("2010", freq="D", periods=2, tz=tz),
+                1: date_range("2010", freq="D", periods=2, tz=tz),
+            }
+        )
+
+        result = df.diff(axis=1)
+        expected = DataFrame(
+            {
+                0: pd.TimedeltaIndex(["NaT", "NaT"]),
+                1: pd.TimedeltaIndex(["0 days", "0 days"]),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_timedelta(self):
+        # GH#4533
+        df = DataFrame(
+            {
+                "time": [Timestamp("20130101 9:01"), Timestamp("20130101 9:02")],
+                "value": [1.0, 2.0],
+            }
+        )
+
+        res = df.diff()
+        exp = DataFrame(
+            [[pd.NaT, np.nan], [pd.Timedelta("00:01:00"), 1]], columns=["time", "value"]
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_diff_mixed_dtype(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((5, 3)))
+        df["A"] = np.array([1, 2, 3, 4, 5], dtype=object)
+
+        result = df.diff()
+        assert result[0].dtype == np.float64
+
+    def test_diff_neg_n(self, datetime_frame):
+        rs = datetime_frame.diff(-1)
+        xp = datetime_frame - datetime_frame.shift(-1)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_diff_float_n(self, datetime_frame):
+        rs = datetime_frame.diff(1.0)
+        xp = datetime_frame.diff(1)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_diff_axis(self):
+        # GH#9727
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0]])
+        tm.assert_frame_equal(
+            df.diff(axis=1), DataFrame([[np.nan, 1.0], [np.nan, 1.0]])
+        )
+        tm.assert_frame_equal(
+            df.diff(axis=0), DataFrame([[np.nan, np.nan], [2.0, 2.0]])
+        )
+
+    def test_diff_period(self):
+        # GH#32995 Don't pass an incorrect axis
+        pi = date_range("2016-01-01", periods=3).to_period("D")
+        df = DataFrame({"A": pi})
+
+        result = df.diff(1, axis=1)
+
+        expected = (df - pd.NaT).astype(object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_axis1_mixed_dtypes(self):
+        # GH#32995 operate column-wise when we have mixed dtypes and axis=1
+        df = DataFrame({"A": range(3), "B": 2 * np.arange(3, dtype=np.float64)})
+
+        expected = DataFrame({"A": [np.nan, np.nan, np.nan], "B": df["B"] / 2})
+
+        result = df.diff(axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        # GH#21437 mixed-float-dtypes
+        df = DataFrame(
+            {"a": np.arange(3, dtype="float32"), "b": np.arange(3, dtype="float64")}
+        )
+        result = df.diff(axis=1)
+        expected = DataFrame({"a": df["a"] * np.nan, "b": df["b"] * 0})
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_axis1_mixed_dtypes_large_periods(self):
+        # GH#32995 operate column-wise when we have mixed dtypes and axis=1
+        df = DataFrame({"A": range(3), "B": 2 * np.arange(3, dtype=np.float64)})
+
+        expected = df * np.nan
+
+        result = df.diff(axis=1, periods=3)
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_axis1_mixed_dtypes_negative_periods(self):
+        # GH#32995 operate column-wise when we have mixed dtypes and axis=1
+        df = DataFrame({"A": range(3), "B": 2 * np.arange(3, dtype=np.float64)})
+
+        expected = DataFrame({"A": -1.0 * df["A"], "B": df["B"] * np.nan})
+
+        result = df.diff(axis=1, periods=-1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_sparse(self):
+        # GH#28813 .diff() should work for sparse dataframes as well
+        sparse_df = DataFrame([[0, 1], [1, 0]], dtype="Sparse[int]")
+
+        result = sparse_df.diff()
+        expected = DataFrame(
+            [[np.nan, np.nan], [1.0, -1.0]], dtype=pd.SparseDtype("float", 0.0)
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "axis,expected",
+        [
+            (
+                0,
+                DataFrame(
+                    {
+                        "a": [np.nan, 0, 1, 0, np.nan, np.nan, np.nan, 0],
+                        "b": [np.nan, 1, np.nan, np.nan, -2, 1, np.nan, np.nan],
+                        "c": np.repeat(np.nan, 8),
+                        "d": [np.nan, 3, 5, 7, 9, 11, 13, 15],
+                    },
+                    dtype="Int64",
+                ),
+            ),
+            (
+                1,
+                DataFrame(
+                    {
+                        "a": np.repeat(np.nan, 8),
+                        "b": [0, 1, np.nan, 1, np.nan, np.nan, np.nan, 0],
+                        "c": np.repeat(np.nan, 8),
+                        "d": np.repeat(np.nan, 8),
+                    },
+                    dtype="Int64",
+                ),
+            ),
+        ],
+    )
+    def test_diff_integer_na(self, axis, expected):
+        # GH#24171 IntegerNA Support for DataFrame.diff()
+        df = DataFrame(
+            {
+                "a": np.repeat([0, 1, np.nan, 2], 2),
+                "b": np.tile([0, 1, np.nan, 2], 2),
+                "c": np.repeat(np.nan, 8),
+                "d": np.arange(1, 9) ** 2,
+            },
+            dtype="Int64",
+        )
+
+        # Test case for default behaviour of diff
+        result = df.diff(axis=axis)
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_readonly(self):
+        # https://github.com/pandas-dev/pandas/issues/35559
+        arr = np.random.default_rng(2).standard_normal((5, 2))
+        arr.flags.writeable = False
+        df = DataFrame(arr)
+        result = df.diff()
+        expected = DataFrame(np.array(df)).diff()
+        tm.assert_frame_equal(result, expected)
+
+    def test_diff_all_int_dtype(self, any_int_numpy_dtype):
+        # GH 14773
+        df = DataFrame(range(5))
+        df = df.astype(any_int_numpy_dtype)
+        result = df.diff()
+        expected_dtype = (
+            "float32" if any_int_numpy_dtype in ("int8", "int16") else "float64"
+        )
+        expected = DataFrame([np.nan, 1.0, 1.0, 1.0, 1.0], dtype=expected_dtype)
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dot.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dot.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e01f67c8794bcf35d2b7be57f8bedcc06c2a137
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dot.py
@@ -0,0 +1,155 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class DotSharedTests:
+    @pytest.fixture
+    def obj(self):
+        raise NotImplementedError
+
+    @pytest.fixture
+    def other(self) -> DataFrame:
+        """
+        other is a DataFrame that is indexed so that obj.dot(other) is valid
+        """
+        raise NotImplementedError
+
+    @pytest.fixture
+    def expected(self, obj, other) -> DataFrame:
+        """
+        The expected result of obj.dot(other)
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def reduced_dim_assert(cls, result, expected):
+        """
+        Assertion about results with 1 fewer dimension that self.obj
+        """
+        raise NotImplementedError
+
+    def test_dot_equiv_values_dot(self, obj, other, expected):
+        # `expected` is constructed from obj.values.dot(other.values)
+        result = obj.dot(other)
+        tm.assert_equal(result, expected)
+
+    def test_dot_2d_ndarray(self, obj, other, expected):
+        # Check ndarray argument; in this case we get matching values,
+        #  but index/columns may not match
+        result = obj.dot(other.values)
+        assert np.all(result == expected.values)
+
+    def test_dot_1d_ndarray(self, obj, expected):
+        # can pass correct-length array
+        row = obj.iloc[0] if obj.ndim == 2 else obj
+
+        result = obj.dot(row.values)
+        expected = obj.dot(row)
+        self.reduced_dim_assert(result, expected)
+
+    def test_dot_series(self, obj, other, expected):
+        # Check series argument
+        result = obj.dot(other["1"])
+        self.reduced_dim_assert(result, expected["1"])
+
+    def test_dot_series_alignment(self, obj, other, expected):
+        result = obj.dot(other.iloc[::-1]["1"])
+        self.reduced_dim_assert(result, expected["1"])
+
+    def test_dot_aligns(self, obj, other, expected):
+        # Check index alignment
+        other2 = other.iloc[::-1]
+        result = obj.dot(other2)
+        tm.assert_equal(result, expected)
+
+    def test_dot_shape_mismatch(self, obj):
+        msg = "Dot product shape mismatch"
+        # exception raised is of type Exception
+        with pytest.raises(Exception, match=msg):
+            obj.dot(obj.values[:3])
+
+    def test_dot_misaligned(self, obj, other):
+        msg = "matrices are not aligned"
+        with pytest.raises(ValueError, match=msg):
+            obj.dot(other.T)
+
+
+class TestSeriesDot(DotSharedTests):
+    @pytest.fixture
+    def obj(self):
+        return Series(
+            np.random.default_rng(2).standard_normal(4), index=["p", "q", "r", "s"]
+        )
+
+    @pytest.fixture
+    def other(self):
+        return DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            index=["1", "2", "3"],
+            columns=["p", "q", "r", "s"],
+        ).T
+
+    @pytest.fixture
+    def expected(self, obj, other):
+        return Series(np.dot(obj.values, other.values), index=other.columns)
+
+    @classmethod
+    def reduced_dim_assert(cls, result, expected):
+        """
+        Assertion about results with 1 fewer dimension that self.obj
+        """
+        tm.assert_almost_equal(result, expected)
+
+
+class TestDataFrameDot(DotSharedTests):
+    @pytest.fixture
+    def obj(self):
+        return DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            index=["a", "b", "c"],
+            columns=["p", "q", "r", "s"],
+        )
+
+    @pytest.fixture
+    def other(self):
+        return DataFrame(
+            np.random.default_rng(2).standard_normal((4, 2)),
+            index=["p", "q", "r", "s"],
+            columns=["1", "2"],
+        )
+
+    @pytest.fixture
+    def expected(self, obj, other):
+        return DataFrame(
+            np.dot(obj.values, other.values), index=obj.index, columns=other.columns
+        )
+
+    @classmethod
+    def reduced_dim_assert(cls, result, expected):
+        """
+        Assertion about results with 1 fewer dimension that self.obj
+        """
+        tm.assert_series_equal(result, expected, check_names=False)
+        assert result.name is None
+
+
+@pytest.mark.parametrize(
+    "dtype,exp_dtype",
+    [("Float32", "Float64"), ("Int16", "Int32"), ("float[pyarrow]", "double[pyarrow]")],
+)
+def test_arrow_dtype(dtype, exp_dtype):
+    pytest.importorskip("pyarrow")
+
+    cols = ["a", "b"]
+    df_a = DataFrame([[1, 2], [3, 4], [5, 6]], columns=cols, dtype="int32")
+    df_b = DataFrame([[1, 0], [0, 1]], index=cols, dtype=dtype)
+    result = df_a.dot(df_b)
+    expected = DataFrame([[1, 2], [3, 4], [5, 6]], dtype=exp_dtype)
+
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_drop.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_drop.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a4882f11e961ea965301caa2e5db69b25a3aa7a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_drop.py
@@ -0,0 +1,546 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.errors import PerformanceWarning
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "msg,labels,level",
+    [
+        (r"labels \[4\] not found in level", 4, "a"),
+        (r"labels \[7\] not found in level", 7, "b"),
+    ],
+)
+def test_drop_raise_exception_if_labels_not_in_level(msg, labels, level):
+    # GH 8594
+    mi = MultiIndex.from_arrays([[1, 2, 3], [4, 5, 6]], names=["a", "b"])
+    s = Series([10, 20, 30], index=mi)
+    df = DataFrame([10, 20, 30], index=mi)
+
+    with pytest.raises(KeyError, match=msg):
+        s.drop(labels, level=level)
+    with pytest.raises(KeyError, match=msg):
+        df.drop(labels, level=level)
+
+
+@pytest.mark.parametrize("labels,level", [(4, "a"), (7, "b")])
+def test_drop_errors_ignore(labels, level):
+    # GH 8594
+    mi = MultiIndex.from_arrays([[1, 2, 3], [4, 5, 6]], names=["a", "b"])
+    s = Series([10, 20, 30], index=mi)
+    df = DataFrame([10, 20, 30], index=mi)
+
+    expected_s = s.drop(labels, level=level, errors="ignore")
+    tm.assert_series_equal(s, expected_s)
+
+    expected_df = df.drop(labels, level=level, errors="ignore")
+    tm.assert_frame_equal(df, expected_df)
+
+
+def test_drop_with_non_unique_datetime_index_and_invalid_keys():
+    # GH 30399
+
+    # define dataframe with unique datetime index
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((5, 3)),
+        columns=["a", "b", "c"],
+        index=pd.date_range("2012", freq="H", periods=5),
+    )
+    # create dataframe with non-unique datetime index
+    df = df.iloc[[0, 2, 2, 3]].copy()
+
+    with pytest.raises(KeyError, match="not found in axis"):
+        df.drop(["a", "b"])  # Dropping with labels not exist in the index
+
+
+class TestDataFrameDrop:
+    def test_drop_names(self):
+        df = DataFrame(
+            [[1, 2, 3], [3, 4, 5], [5, 6, 7]],
+            index=["a", "b", "c"],
+            columns=["d", "e", "f"],
+        )
+        df.index.name, df.columns.name = "first", "second"
+        df_dropped_b = df.drop("b")
+        df_dropped_e = df.drop("e", axis=1)
+        df_inplace_b, df_inplace_e = df.copy(), df.copy()
+        return_value = df_inplace_b.drop("b", inplace=True)
+        assert return_value is None
+        return_value = df_inplace_e.drop("e", axis=1, inplace=True)
+        assert return_value is None
+        for obj in (df_dropped_b, df_dropped_e, df_inplace_b, df_inplace_e):
+            assert obj.index.name == "first"
+            assert obj.columns.name == "second"
+        assert list(df.columns) == ["d", "e", "f"]
+
+        msg = r"\['g'\] not found in axis"
+        with pytest.raises(KeyError, match=msg):
+            df.drop(["g"])
+        with pytest.raises(KeyError, match=msg):
+            df.drop(["g"], axis=1)
+
+        # errors = 'ignore'
+        dropped = df.drop(["g"], errors="ignore")
+        expected = Index(["a", "b", "c"], name="first")
+        tm.assert_index_equal(dropped.index, expected)
+
+        dropped = df.drop(["b", "g"], errors="ignore")
+        expected = Index(["a", "c"], name="first")
+        tm.assert_index_equal(dropped.index, expected)
+
+        dropped = df.drop(["g"], axis=1, errors="ignore")
+        expected = Index(["d", "e", "f"], name="second")
+        tm.assert_index_equal(dropped.columns, expected)
+
+        dropped = df.drop(["d", "g"], axis=1, errors="ignore")
+        expected = Index(["e", "f"], name="second")
+        tm.assert_index_equal(dropped.columns, expected)
+
+        # GH 16398
+        dropped = df.drop([], errors="ignore")
+        expected = Index(["a", "b", "c"], name="first")
+        tm.assert_index_equal(dropped.index, expected)
+
+    def test_drop(self):
+        simple = DataFrame({"A": [1, 2, 3, 4], "B": [0, 1, 2, 3]})
+        tm.assert_frame_equal(simple.drop("A", axis=1), simple[["B"]])
+        tm.assert_frame_equal(simple.drop(["A", "B"], axis="columns"), simple[[]])
+        tm.assert_frame_equal(simple.drop([0, 1, 3], axis=0), simple.loc[[2], :])
+        tm.assert_frame_equal(simple.drop([0, 3], axis="index"), simple.loc[[1, 2], :])
+
+        with pytest.raises(KeyError, match=r"\[5\] not found in axis"):
+            simple.drop(5)
+        with pytest.raises(KeyError, match=r"\['C'\] not found in axis"):
+            simple.drop("C", axis=1)
+        with pytest.raises(KeyError, match=r"\[5\] not found in axis"):
+            simple.drop([1, 5])
+        with pytest.raises(KeyError, match=r"\['C'\] not found in axis"):
+            simple.drop(["A", "C"], axis=1)
+
+        # GH 42881
+        with pytest.raises(KeyError, match=r"\['C', 'D', 'F'\] not found in axis"):
+            simple.drop(["C", "D", "F"], axis=1)
+
+        # errors = 'ignore'
+        tm.assert_frame_equal(simple.drop(5, errors="ignore"), simple)
+        tm.assert_frame_equal(
+            simple.drop([0, 5], errors="ignore"), simple.loc[[1, 2, 3], :]
+        )
+        tm.assert_frame_equal(simple.drop("C", axis=1, errors="ignore"), simple)
+        tm.assert_frame_equal(
+            simple.drop(["A", "C"], axis=1, errors="ignore"), simple[["B"]]
+        )
+
+        # non-unique - wheee!
+        nu_df = DataFrame(
+            list(zip(range(3), range(-3, 1), list("abc"))), columns=["a", "a", "b"]
+        )
+        tm.assert_frame_equal(nu_df.drop("a", axis=1), nu_df[["b"]])
+        tm.assert_frame_equal(nu_df.drop("b", axis="columns"), nu_df["a"])
+        tm.assert_frame_equal(nu_df.drop([]), nu_df)  # GH 16398
+
+        nu_df = nu_df.set_index(Index(["X", "Y", "X"]))
+        nu_df.columns = list("abc")
+        tm.assert_frame_equal(nu_df.drop("X", axis="rows"), nu_df.loc[["Y"], :])
+        tm.assert_frame_equal(nu_df.drop(["X", "Y"], axis=0), nu_df.loc[[], :])
+
+        # inplace cache issue
+        # GH#5628
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)), columns=list("abc")
+        )
+        expected = df[~(df.b > 0)]
+        return_value = df.drop(labels=df[df.b > 0].index, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(df, expected)
+
+    def test_drop_multiindex_not_lexsorted(self):
+        # GH#11640
+
+        # define the lexsorted version
+        lexsorted_mi = MultiIndex.from_tuples(
+            [("a", ""), ("b1", "c1"), ("b2", "c2")], names=["b", "c"]
+        )
+        lexsorted_df = DataFrame([[1, 3, 4]], columns=lexsorted_mi)
+        assert lexsorted_df.columns._is_lexsorted()
+
+        # define the non-lexsorted version
+        not_lexsorted_df = DataFrame(
+            columns=["a", "b", "c", "d"], data=[[1, "b1", "c1", 3], [1, "b2", "c2", 4]]
+        )
+        not_lexsorted_df = not_lexsorted_df.pivot_table(
+            index="a", columns=["b", "c"], values="d"
+        )
+        not_lexsorted_df = not_lexsorted_df.reset_index()
+        assert not not_lexsorted_df.columns._is_lexsorted()
+
+        expected = lexsorted_df.drop("a", axis=1).astype(float)
+        with tm.assert_produces_warning(PerformanceWarning):
+            result = not_lexsorted_df.drop("a", axis=1)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_api_equivalence(self):
+        # equivalence of the labels/axis and index/columns API's (GH#12392)
+        df = DataFrame(
+            [[1, 2, 3], [3, 4, 5], [5, 6, 7]],
+            index=["a", "b", "c"],
+            columns=["d", "e", "f"],
+        )
+
+        res1 = df.drop("a")
+        res2 = df.drop(index="a")
+        tm.assert_frame_equal(res1, res2)
+
+        res1 = df.drop("d", axis=1)
+        res2 = df.drop(columns="d")
+        tm.assert_frame_equal(res1, res2)
+
+        res1 = df.drop(labels="e", axis=1)
+        res2 = df.drop(columns="e")
+        tm.assert_frame_equal(res1, res2)
+
+        res1 = df.drop(["a"], axis=0)
+        res2 = df.drop(index=["a"])
+        tm.assert_frame_equal(res1, res2)
+
+        res1 = df.drop(["a"], axis=0).drop(["d"], axis=1)
+        res2 = df.drop(index=["a"], columns=["d"])
+        tm.assert_frame_equal(res1, res2)
+
+        msg = "Cannot specify both 'labels' and 'index'/'columns'"
+        with pytest.raises(ValueError, match=msg):
+            df.drop(labels="a", index="b")
+
+        with pytest.raises(ValueError, match=msg):
+            df.drop(labels="a", columns="b")
+
+        msg = "Need to specify at least one of 'labels', 'index' or 'columns'"
+        with pytest.raises(ValueError, match=msg):
+            df.drop(axis=1)
+
+    data = [[1, 2, 3], [1, 2, 3]]
+
+    @pytest.mark.parametrize(
+        "actual",
+        [
+            DataFrame(data=data, index=["a", "a"]),
+            DataFrame(data=data, index=["a", "b"]),
+            DataFrame(data=data, index=["a", "b"]).set_index([0, 1]),
+            DataFrame(data=data, index=["a", "a"]).set_index([0, 1]),
+        ],
+    )
+    def test_raise_on_drop_duplicate_index(self, actual):
+        # GH#19186
+        level = 0 if isinstance(actual.index, MultiIndex) else None
+        msg = re.escape("\"['c'] not found in axis\"")
+        with pytest.raises(KeyError, match=msg):
+            actual.drop("c", level=level, axis=0)
+        with pytest.raises(KeyError, match=msg):
+            actual.T.drop("c", level=level, axis=1)
+        expected_no_err = actual.drop("c", axis=0, level=level, errors="ignore")
+        tm.assert_frame_equal(expected_no_err, actual)
+        expected_no_err = actual.T.drop("c", axis=1, level=level, errors="ignore")
+        tm.assert_frame_equal(expected_no_err.T, actual)
+
+    @pytest.mark.parametrize("index", [[1, 2, 3], [1, 1, 2]])
+    @pytest.mark.parametrize("drop_labels", [[], [1], [2]])
+    def test_drop_empty_list(self, index, drop_labels):
+        # GH#21494
+        expected_index = [i for i in index if i not in drop_labels]
+        frame = DataFrame(index=index).drop(drop_labels)
+        tm.assert_frame_equal(frame, DataFrame(index=expected_index))
+
+    @pytest.mark.parametrize("index", [[1, 2, 3], [1, 2, 2]])
+    @pytest.mark.parametrize("drop_labels", [[1, 4], [4, 5]])
+    def test_drop_non_empty_list(self, index, drop_labels):
+        # GH# 21494
+        with pytest.raises(KeyError, match="not found in axis"):
+            DataFrame(index=index).drop(drop_labels)
+
+    @pytest.mark.parametrize(
+        "empty_listlike",
+        [
+            [],
+            {},
+            np.array([]),
+            Series([], dtype="datetime64[ns]"),
+            Index([]),
+            DatetimeIndex([]),
+        ],
+    )
+    def test_drop_empty_listlike_non_unique_datetime_index(self, empty_listlike):
+        # GH#27994
+        data = {"column_a": [5, 10], "column_b": ["one", "two"]}
+        index = [Timestamp("2021-01-01"), Timestamp("2021-01-01")]
+        df = DataFrame(data, index=index)
+
+        # Passing empty list-like should return the same DataFrame.
+        expected = df.copy()
+        result = df.drop(empty_listlike)
+        tm.assert_frame_equal(result, expected)
+
+    def test_mixed_depth_drop(self):
+        arrays = [
+            ["a", "top", "top", "routine1", "routine1", "routine2"],
+            ["", "OD", "OD", "result1", "result2", "result1"],
+            ["", "wx", "wy", "", "", ""],
+        ]
+
+        tuples = sorted(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples)
+        df = DataFrame(np.random.default_rng(2).standard_normal((4, 6)), columns=index)
+
+        result = df.drop("a", axis=1)
+        expected = df.drop([("a", "", "")], axis=1)
+        tm.assert_frame_equal(expected, result)
+
+        result = df.drop(["top"], axis=1)
+        expected = df.drop([("top", "OD", "wx")], axis=1)
+        expected = expected.drop([("top", "OD", "wy")], axis=1)
+        tm.assert_frame_equal(expected, result)
+
+        result = df.drop(("top", "OD", "wx"), axis=1)
+        expected = df.drop([("top", "OD", "wx")], axis=1)
+        tm.assert_frame_equal(expected, result)
+
+        expected = df.drop([("top", "OD", "wy")], axis=1)
+        expected = df.drop("top", axis=1)
+
+        result = df.drop("result1", level=1, axis=1)
+        expected = df.drop(
+            [("routine1", "result1", ""), ("routine2", "result1", "")], axis=1
+        )
+        tm.assert_frame_equal(expected, result)
+
+    def test_drop_multiindex_other_level_nan(self):
+        # GH#12754
+        df = (
+            DataFrame(
+                {
+                    "A": ["one", "one", "two", "two"],
+                    "B": [np.nan, 0.0, 1.0, 2.0],
+                    "C": ["a", "b", "c", "c"],
+                    "D": [1, 2, 3, 4],
+                }
+            )
+            .set_index(["A", "B", "C"])
+            .sort_index()
+        )
+        result = df.drop("c", level="C")
+        expected = DataFrame(
+            [2, 1],
+            columns=["D"],
+            index=MultiIndex.from_tuples(
+                [("one", 0.0, "b"), ("one", np.nan, "a")], names=["A", "B", "C"]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_nonunique(self):
+        df = DataFrame(
+            [
+                ["x-a", "x", "a", 1.5],
+                ["x-a", "x", "a", 1.2],
+                ["z-c", "z", "c", 3.1],
+                ["x-a", "x", "a", 4.1],
+                ["x-b", "x", "b", 5.1],
+                ["x-b", "x", "b", 4.1],
+                ["x-b", "x", "b", 2.2],
+                ["y-a", "y", "a", 1.2],
+                ["z-b", "z", "b", 2.1],
+            ],
+            columns=["var1", "var2", "var3", "var4"],
+        )
+
+        grp_size = df.groupby("var1").size()
+        drop_idx = grp_size.loc[grp_size == 1]
+
+        idf = df.set_index(["var1", "var2", "var3"])
+
+        # it works! GH#2101
+        result = idf.drop(drop_idx.index, level=0).reset_index()
+        expected = df[-df.var1.isin(drop_idx.index)]
+
+        result.index = expected.index
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_level(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        result = frame.drop(["bar", "qux"], level="first")
+        expected = frame.iloc[[0, 1, 2, 5, 6]]
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.drop(["two"], level="second")
+        expected = frame.iloc[[0, 2, 3, 6, 7, 9]]
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.T.drop(["bar", "qux"], axis=1, level="first")
+        expected = frame.iloc[[0, 1, 2, 5, 6]].T
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.T.drop(["two"], axis=1, level="second")
+        expected = frame.iloc[[0, 2, 3, 6, 7, 9]].T
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_level_nonunique_datetime(self):
+        # GH#12701
+        idx = Index([2, 3, 4, 4, 5], name="id")
+        idxdt = pd.to_datetime(
+            [
+                "2016-03-23 14:00",
+                "2016-03-23 15:00",
+                "2016-03-23 16:00",
+                "2016-03-23 16:00",
+                "2016-03-23 17:00",
+            ]
+        )
+        df = DataFrame(np.arange(10).reshape(5, 2), columns=list("ab"), index=idx)
+        df["tstamp"] = idxdt
+        df = df.set_index("tstamp", append=True)
+        ts = Timestamp("201603231600")
+        assert df.index.is_unique is False
+
+        result = df.drop(ts, level="tstamp")
+        expected = df.loc[idx != 4]
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_tz_aware_timestamp_across_dst(self, frame_or_series):
+        # GH#21761
+        start = Timestamp("2017-10-29", tz="Europe/Berlin")
+        end = Timestamp("2017-10-29 04:00:00", tz="Europe/Berlin")
+        index = pd.date_range(start, end, freq="15min")
+        data = frame_or_series(data=[1] * len(index), index=index)
+        result = data.drop(start)
+        expected_start = Timestamp("2017-10-29 00:15:00", tz="Europe/Berlin")
+        expected_idx = pd.date_range(expected_start, end, freq="15min")
+        expected = frame_or_series(data=[1] * len(expected_idx), index=expected_idx)
+        tm.assert_equal(result, expected)
+
+    def test_drop_preserve_names(self):
+        index = MultiIndex.from_arrays(
+            [[0, 0, 0, 1, 1, 1], [1, 2, 3, 1, 2, 3]], names=["one", "two"]
+        )
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((6, 3)), index=index)
+
+        result = df.drop([(0, 2)])
+        assert result.index.names == ("one", "two")
+
+    @pytest.mark.parametrize(
+        "operation", ["__iadd__", "__isub__", "__imul__", "__ipow__"]
+    )
+    @pytest.mark.parametrize("inplace", [False, True])
+    def test_inplace_drop_and_operation(self, operation, inplace):
+        # GH#30484
+        df = DataFrame({"x": range(5)})
+        expected = df.copy()
+        df["y"] = range(5)
+        y = df["y"]
+
+        with tm.assert_produces_warning(None):
+            if inplace:
+                df.drop("y", axis=1, inplace=inplace)
+            else:
+                df = df.drop("y", axis=1, inplace=inplace)
+
+            # Perform operation and check result
+            getattr(y, operation)(1)
+            tm.assert_frame_equal(df, expected)
+
+    def test_drop_with_non_unique_multiindex(self):
+        # GH#36293
+        mi = MultiIndex.from_arrays([["x", "y", "x"], ["i", "j", "i"]])
+        df = DataFrame([1, 2, 3], index=mi)
+        result = df.drop(index="x")
+        expected = DataFrame([2], index=MultiIndex.from_arrays([["y"], ["j"]]))
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("indexer", [("a", "a"), [("a", "a")]])
+    def test_drop_tuple_with_non_unique_multiindex(self, indexer):
+        # GH#42771
+        idx = MultiIndex.from_product([["a", "b"], ["a", "a"]])
+        df = DataFrame({"x": range(len(idx))}, index=idx)
+        result = df.drop(index=[("a", "a")])
+        expected = DataFrame(
+            {"x": [2, 3]}, index=MultiIndex.from_tuples([("b", "a"), ("b", "a")])
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_with_duplicate_columns(self):
+        df = DataFrame(
+            [[1, 5, 7.0], [1, 5, 7.0], [1, 5, 7.0]], columns=["bar", "a", "a"]
+        )
+        result = df.drop(["a"], axis=1)
+        expected = DataFrame([[1], [1], [1]], columns=["bar"])
+        tm.assert_frame_equal(result, expected)
+        result = df.drop("a", axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_with_duplicate_columns2(self):
+        # drop buggy GH#6240
+        df = DataFrame(
+            {
+                "A": np.random.default_rng(2).standard_normal(5),
+                "B": np.random.default_rng(2).standard_normal(5),
+                "C": np.random.default_rng(2).standard_normal(5),
+                "D": ["a", "b", "c", "d", "e"],
+            }
+        )
+
+        expected = df.take([0, 1, 1], axis=1)
+        df2 = df.take([2, 0, 1, 2, 1], axis=1)
+        result = df2.drop("C", axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_inplace_no_leftover_column_reference(self):
+        # GH 13934
+        df = DataFrame({"a": [1, 2, 3]})
+        a = df.a
+        df.drop(["a"], axis=1, inplace=True)
+        tm.assert_index_equal(df.columns, Index([], dtype="object"))
+        a -= a.mean()
+        tm.assert_index_equal(df.columns, Index([], dtype="object"))
+
+    def test_drop_level_missing_label_multiindex(self):
+        # GH 18561
+        df = DataFrame(index=MultiIndex.from_product([range(3), range(3)]))
+        with pytest.raises(KeyError, match="labels \\[5\\] not found in level"):
+            df.drop(5, level=0)
+
+    @pytest.mark.parametrize("idx, level", [(["a", "b"], 0), (["a"], None)])
+    def test_drop_index_ea_dtype(self, any_numeric_ea_dtype, idx, level):
+        # GH#45860
+        df = DataFrame(
+            {"a": [1, 2, 2, pd.NA], "b": 100}, dtype=any_numeric_ea_dtype
+        ).set_index(idx)
+        result = df.drop(Index([2, pd.NA]), level=level)
+        expected = DataFrame(
+            {"a": [1], "b": 100}, dtype=any_numeric_ea_dtype
+        ).set_index(idx)
+        tm.assert_frame_equal(result, expected)
+
+    def test_drop_parse_strings_datetime_index(self):
+        # GH #5355
+        df = DataFrame(
+            {"a": [1, 2], "b": [1, 2]},
+            index=[Timestamp("2000-01-03"), Timestamp("2000-01-04")],
+        )
+        result = df.drop("2000-01-03", axis=0)
+        expected = DataFrame({"a": [2], "b": [2]}, index=[Timestamp("2000-01-04")])
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_drop_duplicates.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_drop_duplicates.py
new file mode 100644
index 0000000000000000000000000000000000000000..df12139258a6d3057bf37051ed05d9091d3d0e7d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_drop_duplicates.py
@@ -0,0 +1,473 @@
+from datetime import datetime
+import re
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    NaT,
+    concat,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("subset", ["a", ["a"], ["a", "B"]])
+def test_drop_duplicates_with_misspelled_column_name(subset):
+    # GH 19730
+    df = DataFrame({"A": [0, 0, 1], "B": [0, 0, 1], "C": [0, 0, 1]})
+    msg = re.escape("Index(['a'], dtype='object')")
+
+    with pytest.raises(KeyError, match=msg):
+        df.drop_duplicates(subset)
+
+
+def test_drop_duplicates():
+    df = DataFrame(
+        {
+            "AAA": ["foo", "bar", "foo", "bar", "foo", "bar", "bar", "foo"],
+            "B": ["one", "one", "two", "two", "two", "two", "one", "two"],
+            "C": [1, 1, 2, 2, 2, 2, 1, 2],
+            "D": range(8),
+        }
+    )
+    # single column
+    result = df.drop_duplicates("AAA")
+    expected = df[:2]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("AAA", keep="last")
+    expected = df.loc[[6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("AAA", keep=False)
+    expected = df.loc[[]]
+    tm.assert_frame_equal(result, expected)
+    assert len(result) == 0
+
+    # multi column
+    expected = df.loc[[0, 1, 2, 3]]
+    result = df.drop_duplicates(np.array(["AAA", "B"]))
+    tm.assert_frame_equal(result, expected)
+    result = df.drop_duplicates(["AAA", "B"])
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(("AAA", "B"), keep="last")
+    expected = df.loc[[0, 5, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(("AAA", "B"), keep=False)
+    expected = df.loc[[0]]
+    tm.assert_frame_equal(result, expected)
+
+    # consider everything
+    df2 = df.loc[:, ["AAA", "B", "C"]]
+
+    result = df2.drop_duplicates()
+    # in this case only
+    expected = df2.drop_duplicates(["AAA", "B"])
+    tm.assert_frame_equal(result, expected)
+
+    result = df2.drop_duplicates(keep="last")
+    expected = df2.drop_duplicates(["AAA", "B"], keep="last")
+    tm.assert_frame_equal(result, expected)
+
+    result = df2.drop_duplicates(keep=False)
+    expected = df2.drop_duplicates(["AAA", "B"], keep=False)
+    tm.assert_frame_equal(result, expected)
+
+    # integers
+    result = df.drop_duplicates("C")
+    expected = df.iloc[[0, 2]]
+    tm.assert_frame_equal(result, expected)
+    result = df.drop_duplicates("C", keep="last")
+    expected = df.iloc[[-2, -1]]
+    tm.assert_frame_equal(result, expected)
+
+    df["E"] = df["C"].astype("int8")
+    result = df.drop_duplicates("E")
+    expected = df.iloc[[0, 2]]
+    tm.assert_frame_equal(result, expected)
+    result = df.drop_duplicates("E", keep="last")
+    expected = df.iloc[[-2, -1]]
+    tm.assert_frame_equal(result, expected)
+
+    # GH 11376
+    df = DataFrame({"x": [7, 6, 3, 3, 4, 8, 0], "y": [0, 6, 5, 5, 9, 1, 2]})
+    expected = df.loc[df.index != 3]
+    tm.assert_frame_equal(df.drop_duplicates(), expected)
+
+    df = DataFrame([[1, 0], [0, 2]])
+    tm.assert_frame_equal(df.drop_duplicates(), df)
+
+    df = DataFrame([[-2, 0], [0, -4]])
+    tm.assert_frame_equal(df.drop_duplicates(), df)
+
+    x = np.iinfo(np.int64).max / 3 * 2
+    df = DataFrame([[-x, x], [0, x + 4]])
+    tm.assert_frame_equal(df.drop_duplicates(), df)
+
+    df = DataFrame([[-x, x], [x, x + 4]])
+    tm.assert_frame_equal(df.drop_duplicates(), df)
+
+    # GH 11864
+    df = DataFrame([i] * 9 for i in range(16))
+    df = concat([df, DataFrame([[1] + [0] * 8])], ignore_index=True)
+
+    for keep in ["first", "last", False]:
+        assert df.duplicated(keep=keep).sum() == 0
+
+
+def test_drop_duplicates_with_duplicate_column_names():
+    # GH17836
+    df = DataFrame([[1, 2, 5], [3, 4, 6], [3, 4, 7]], columns=["a", "a", "b"])
+
+    result0 = df.drop_duplicates()
+    tm.assert_frame_equal(result0, df)
+
+    result1 = df.drop_duplicates("a")
+    expected1 = df[:2]
+    tm.assert_frame_equal(result1, expected1)
+
+
+def test_drop_duplicates_for_take_all():
+    df = DataFrame(
+        {
+            "AAA": ["foo", "bar", "baz", "bar", "foo", "bar", "qux", "foo"],
+            "B": ["one", "one", "two", "two", "two", "two", "one", "two"],
+            "C": [1, 1, 2, 2, 2, 2, 1, 2],
+            "D": range(8),
+        }
+    )
+    # single column
+    result = df.drop_duplicates("AAA")
+    expected = df.iloc[[0, 1, 2, 6]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("AAA", keep="last")
+    expected = df.iloc[[2, 5, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("AAA", keep=False)
+    expected = df.iloc[[2, 6]]
+    tm.assert_frame_equal(result, expected)
+
+    # multiple columns
+    result = df.drop_duplicates(["AAA", "B"])
+    expected = df.iloc[[0, 1, 2, 3, 4, 6]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(["AAA", "B"], keep="last")
+    expected = df.iloc[[0, 1, 2, 5, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(["AAA", "B"], keep=False)
+    expected = df.iloc[[0, 1, 2, 6]]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_drop_duplicates_tuple():
+    df = DataFrame(
+        {
+            ("AA", "AB"): ["foo", "bar", "foo", "bar", "foo", "bar", "bar", "foo"],
+            "B": ["one", "one", "two", "two", "two", "two", "one", "two"],
+            "C": [1, 1, 2, 2, 2, 2, 1, 2],
+            "D": range(8),
+        }
+    )
+    # single column
+    result = df.drop_duplicates(("AA", "AB"))
+    expected = df[:2]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(("AA", "AB"), keep="last")
+    expected = df.loc[[6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(("AA", "AB"), keep=False)
+    expected = df.loc[[]]  # empty df
+    assert len(result) == 0
+    tm.assert_frame_equal(result, expected)
+
+    # multi column
+    expected = df.loc[[0, 1, 2, 3]]
+    result = df.drop_duplicates((("AA", "AB"), "B"))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "df",
+    [
+        DataFrame(),
+        DataFrame(columns=[]),
+        DataFrame(columns=["A", "B", "C"]),
+        DataFrame(index=[]),
+        DataFrame(index=["A", "B", "C"]),
+    ],
+)
+def test_drop_duplicates_empty(df):
+    # GH 20516
+    result = df.drop_duplicates()
+    tm.assert_frame_equal(result, df)
+
+    result = df.copy()
+    result.drop_duplicates(inplace=True)
+    tm.assert_frame_equal(result, df)
+
+
+def test_drop_duplicates_NA():
+    # none
+    df = DataFrame(
+        {
+            "A": [None, None, "foo", "bar", "foo", "bar", "bar", "foo"],
+            "B": ["one", "one", "two", "two", "two", "two", "one", "two"],
+            "C": [1.0, np.nan, np.nan, np.nan, 1.0, 1.0, 1, 1.0],
+            "D": range(8),
+        }
+    )
+    # single column
+    result = df.drop_duplicates("A")
+    expected = df.loc[[0, 2, 3]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("A", keep="last")
+    expected = df.loc[[1, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("A", keep=False)
+    expected = df.loc[[]]  # empty df
+    tm.assert_frame_equal(result, expected)
+    assert len(result) == 0
+
+    # multi column
+    result = df.drop_duplicates(["A", "B"])
+    expected = df.loc[[0, 2, 3, 6]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(["A", "B"], keep="last")
+    expected = df.loc[[1, 5, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(["A", "B"], keep=False)
+    expected = df.loc[[6]]
+    tm.assert_frame_equal(result, expected)
+
+    # nan
+    df = DataFrame(
+        {
+            "A": ["foo", "bar", "foo", "bar", "foo", "bar", "bar", "foo"],
+            "B": ["one", "one", "two", "two", "two", "two", "one", "two"],
+            "C": [1.0, np.nan, np.nan, np.nan, 1.0, 1.0, 1, 1.0],
+            "D": range(8),
+        }
+    )
+    # single column
+    result = df.drop_duplicates("C")
+    expected = df[:2]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("C", keep="last")
+    expected = df.loc[[3, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("C", keep=False)
+    expected = df.loc[[]]  # empty df
+    tm.assert_frame_equal(result, expected)
+    assert len(result) == 0
+
+    # multi column
+    result = df.drop_duplicates(["C", "B"])
+    expected = df.loc[[0, 1, 2, 4]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(["C", "B"], keep="last")
+    expected = df.loc[[1, 3, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates(["C", "B"], keep=False)
+    expected = df.loc[[1]]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_drop_duplicates_NA_for_take_all():
+    # none
+    df = DataFrame(
+        {
+            "A": [None, None, "foo", "bar", "foo", "baz", "bar", "qux"],
+            "C": [1.0, np.nan, np.nan, np.nan, 1.0, 2.0, 3, 1.0],
+        }
+    )
+
+    # single column
+    result = df.drop_duplicates("A")
+    expected = df.iloc[[0, 2, 3, 5, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("A", keep="last")
+    expected = df.iloc[[1, 4, 5, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("A", keep=False)
+    expected = df.iloc[[5, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    # nan
+
+    # single column
+    result = df.drop_duplicates("C")
+    expected = df.iloc[[0, 1, 5, 6]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("C", keep="last")
+    expected = df.iloc[[3, 5, 6, 7]]
+    tm.assert_frame_equal(result, expected)
+
+    result = df.drop_duplicates("C", keep=False)
+    expected = df.iloc[[5, 6]]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_drop_duplicates_inplace():
+    orig = DataFrame(
+        {
+            "A": ["foo", "bar", "foo", "bar", "foo", "bar", "bar", "foo"],
+            "B": ["one", "one", "two", "two", "two", "two", "one", "two"],
+            "C": [1, 1, 2, 2, 2, 2, 1, 2],
+            "D": range(8),
+        }
+    )
+    # single column
+    df = orig.copy()
+    return_value = df.drop_duplicates("A", inplace=True)
+    expected = orig[:2]
+    result = df
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    df = orig.copy()
+    return_value = df.drop_duplicates("A", keep="last", inplace=True)
+    expected = orig.loc[[6, 7]]
+    result = df
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    df = orig.copy()
+    return_value = df.drop_duplicates("A", keep=False, inplace=True)
+    expected = orig.loc[[]]
+    result = df
+    tm.assert_frame_equal(result, expected)
+    assert len(df) == 0
+    assert return_value is None
+
+    # multi column
+    df = orig.copy()
+    return_value = df.drop_duplicates(["A", "B"], inplace=True)
+    expected = orig.loc[[0, 1, 2, 3]]
+    result = df
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    df = orig.copy()
+    return_value = df.drop_duplicates(["A", "B"], keep="last", inplace=True)
+    expected = orig.loc[[0, 5, 6, 7]]
+    result = df
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    df = orig.copy()
+    return_value = df.drop_duplicates(["A", "B"], keep=False, inplace=True)
+    expected = orig.loc[[0]]
+    result = df
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    # consider everything
+    orig2 = orig.loc[:, ["A", "B", "C"]].copy()
+
+    df2 = orig2.copy()
+    return_value = df2.drop_duplicates(inplace=True)
+    # in this case only
+    expected = orig2.drop_duplicates(["A", "B"])
+    result = df2
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    df2 = orig2.copy()
+    return_value = df2.drop_duplicates(keep="last", inplace=True)
+    expected = orig2.drop_duplicates(["A", "B"], keep="last")
+    result = df2
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+    df2 = orig2.copy()
+    return_value = df2.drop_duplicates(keep=False, inplace=True)
+    expected = orig2.drop_duplicates(["A", "B"], keep=False)
+    result = df2
+    tm.assert_frame_equal(result, expected)
+    assert return_value is None
+
+
+@pytest.mark.parametrize("inplace", [True, False])
+@pytest.mark.parametrize(
+    "origin_dict, output_dict, ignore_index, output_index",
+    [
+        ({"A": [2, 2, 3]}, {"A": [2, 3]}, True, [0, 1]),
+        ({"A": [2, 2, 3]}, {"A": [2, 3]}, False, [0, 2]),
+        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, True, [0, 1]),
+        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, False, [0, 2]),
+    ],
+)
+def test_drop_duplicates_ignore_index(
+    inplace, origin_dict, output_dict, ignore_index, output_index
+):
+    # GH 30114
+    df = DataFrame(origin_dict)
+    expected = DataFrame(output_dict, index=output_index)
+
+    if inplace:
+        result_df = df.copy()
+        result_df.drop_duplicates(ignore_index=ignore_index, inplace=inplace)
+    else:
+        result_df = df.drop_duplicates(ignore_index=ignore_index, inplace=inplace)
+
+    tm.assert_frame_equal(result_df, expected)
+    tm.assert_frame_equal(df, DataFrame(origin_dict))
+
+
+def test_drop_duplicates_null_in_object_column(nulls_fixture):
+    # https://github.com/pandas-dev/pandas/issues/32992
+    df = DataFrame([[1, nulls_fixture], [2, "a"]], dtype=object)
+    result = df.drop_duplicates()
+    tm.assert_frame_equal(result, df)
+
+
+def test_drop_duplicates_series_vs_dataframe(keep):
+    # GH#14192
+    df = DataFrame(
+        {
+            "a": [1, 1, 1, "one", "one"],
+            "b": [2, 2, np.nan, np.nan, np.nan],
+            "c": [3, 3, np.nan, np.nan, "three"],
+            "d": [1, 2, 3, 4, 4],
+            "e": [
+                datetime(2015, 1, 1),
+                datetime(2015, 1, 1),
+                datetime(2015, 2, 1),
+                NaT,
+                NaT,
+            ],
+        }
+    )
+    for column in df.columns:
+        dropped_frame = df[[column]].drop_duplicates(keep=keep)
+        dropped_series = df[column].drop_duplicates(keep=keep)
+        tm.assert_frame_equal(dropped_frame, dropped_series.to_frame())
+
+
+@pytest.mark.parametrize("arg", [[1], 1, "True", [], 0])
+def test_drop_duplicates_non_boolean_ignore_index(arg):
+    # GH#38274
+    df = DataFrame({"a": [1, 2, 1, 3]})
+    msg = '^For argument "ignore_index" expected type bool, received type .*.$'
+    with pytest.raises(ValueError, match=msg):
+        df.drop_duplicates(ignore_index=arg)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_droplevel.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_droplevel.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1302d4b73f2b9c8e74b06c70ec29a92c1e48723
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_droplevel.py
@@ -0,0 +1,36 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+)
+import pandas._testing as tm
+
+
+class TestDropLevel:
+    def test_droplevel(self, frame_or_series):
+        # GH#20342
+        cols = MultiIndex.from_tuples(
+            [("c", "e"), ("d", "f")], names=["level_1", "level_2"]
+        )
+        mi = MultiIndex.from_tuples([(1, 2), (5, 6), (9, 10)], names=["a", "b"])
+        df = DataFrame([[3, 4], [7, 8], [11, 12]], index=mi, columns=cols)
+        if frame_or_series is not DataFrame:
+            df = df.iloc[:, 0]
+
+        # test that dropping of a level in index works
+        expected = df.reset_index("a", drop=True)
+        result = df.droplevel("a", axis="index")
+        tm.assert_equal(result, expected)
+
+        if frame_or_series is DataFrame:
+            # test that dropping of a level in columns works
+            expected = df.copy()
+            expected.columns = Index(["c", "d"], name="level_1")
+            result = df.droplevel("level_2", axis="columns")
+            tm.assert_equal(result, expected)
+        else:
+            # test that droplevel raises ValueError on axis != 0
+            with pytest.raises(ValueError, match="No axis named columns"):
+                df.droplevel(1, axis="columns")
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dropna.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dropna.py
new file mode 100644
index 0000000000000000000000000000000000000000..7899b4aeac3fdef6548f3aadf76ff7718418f089
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dropna.py
@@ -0,0 +1,285 @@
+import datetime
+
+import dateutil
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameMissingData:
+    def test_dropEmptyRows(self, float_frame):
+        N = len(float_frame.index)
+        mat = np.random.default_rng(2).standard_normal(N)
+        mat[:5] = np.nan
+
+        frame = DataFrame({"foo": mat}, index=float_frame.index)
+        original = Series(mat, index=float_frame.index, name="foo")
+        expected = original.dropna()
+        inplace_frame1, inplace_frame2 = frame.copy(), frame.copy()
+
+        smaller_frame = frame.dropna(how="all")
+        # check that original was preserved
+        tm.assert_series_equal(frame["foo"], original)
+        return_value = inplace_frame1.dropna(how="all", inplace=True)
+        tm.assert_series_equal(smaller_frame["foo"], expected)
+        tm.assert_series_equal(inplace_frame1["foo"], expected)
+        assert return_value is None
+
+        smaller_frame = frame.dropna(how="all", subset=["foo"])
+        return_value = inplace_frame2.dropna(how="all", subset=["foo"], inplace=True)
+        tm.assert_series_equal(smaller_frame["foo"], expected)
+        tm.assert_series_equal(inplace_frame2["foo"], expected)
+        assert return_value is None
+
+    def test_dropIncompleteRows(self, float_frame):
+        N = len(float_frame.index)
+        mat = np.random.default_rng(2).standard_normal(N)
+        mat[:5] = np.nan
+
+        frame = DataFrame({"foo": mat}, index=float_frame.index)
+        frame["bar"] = 5
+        original = Series(mat, index=float_frame.index, name="foo")
+        inp_frame1, inp_frame2 = frame.copy(), frame.copy()
+
+        smaller_frame = frame.dropna()
+        tm.assert_series_equal(frame["foo"], original)
+        return_value = inp_frame1.dropna(inplace=True)
+
+        exp = Series(mat[5:], index=float_frame.index[5:], name="foo")
+        tm.assert_series_equal(smaller_frame["foo"], exp)
+        tm.assert_series_equal(inp_frame1["foo"], exp)
+        assert return_value is None
+
+        samesize_frame = frame.dropna(subset=["bar"])
+        tm.assert_series_equal(frame["foo"], original)
+        assert (frame["bar"] == 5).all()
+        return_value = inp_frame2.dropna(subset=["bar"], inplace=True)
+        tm.assert_index_equal(samesize_frame.index, float_frame.index)
+        tm.assert_index_equal(inp_frame2.index, float_frame.index)
+        assert return_value is None
+
+    def test_dropna(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((6, 4)))
+        df.iloc[:2, 2] = np.nan
+
+        dropped = df.dropna(axis=1)
+        expected = df.loc[:, [0, 1, 3]]
+        inp = df.copy()
+        return_value = inp.dropna(axis=1, inplace=True)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
+        assert return_value is None
+
+        dropped = df.dropna(axis=0)
+        expected = df.loc[list(range(2, 6))]
+        inp = df.copy()
+        return_value = inp.dropna(axis=0, inplace=True)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
+        assert return_value is None
+
+        # threshold
+        dropped = df.dropna(axis=1, thresh=5)
+        expected = df.loc[:, [0, 1, 3]]
+        inp = df.copy()
+        return_value = inp.dropna(axis=1, thresh=5, inplace=True)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
+        assert return_value is None
+
+        dropped = df.dropna(axis=0, thresh=4)
+        expected = df.loc[range(2, 6)]
+        inp = df.copy()
+        return_value = inp.dropna(axis=0, thresh=4, inplace=True)
+        tm.assert_frame_equal(dropped, expected)
+        tm.assert_frame_equal(inp, expected)
+        assert return_value is None
+
+        dropped = df.dropna(axis=1, thresh=4)
+        tm.assert_frame_equal(dropped, df)
+
+        dropped = df.dropna(axis=1, thresh=3)
+        tm.assert_frame_equal(dropped, df)
+
+        # subset
+        dropped = df.dropna(axis=0, subset=[0, 1, 3])
+        inp = df.copy()
+        return_value = inp.dropna(axis=0, subset=[0, 1, 3], inplace=True)
+        tm.assert_frame_equal(dropped, df)
+        tm.assert_frame_equal(inp, df)
+        assert return_value is None
+
+        # all
+        dropped = df.dropna(axis=1, how="all")
+        tm.assert_frame_equal(dropped, df)
+
+        df[2] = np.nan
+        dropped = df.dropna(axis=1, how="all")
+        expected = df.loc[:, [0, 1, 3]]
+        tm.assert_frame_equal(dropped, expected)
+
+        # bad input
+        msg = "No axis named 3 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.dropna(axis=3)
+
+    def test_drop_and_dropna_caching(self):
+        # tst that cacher updates
+        original = Series([1, 2, np.nan], name="A")
+        expected = Series([1, 2], dtype=original.dtype, name="A")
+        df = DataFrame({"A": original.values.copy()})
+        df2 = df.copy()
+        df["A"].dropna()
+        tm.assert_series_equal(df["A"], original)
+
+        ser = df["A"]
+        return_value = ser.dropna(inplace=True)
+        tm.assert_series_equal(ser, expected)
+        tm.assert_series_equal(df["A"], original)
+        assert return_value is None
+
+        df2["A"].drop([1])
+        tm.assert_series_equal(df2["A"], original)
+
+        ser = df2["A"]
+        return_value = ser.drop([1], inplace=True)
+        tm.assert_series_equal(ser, original.drop([1]))
+        tm.assert_series_equal(df2["A"], original)
+        assert return_value is None
+
+    def test_dropna_corner(self, float_frame):
+        # bad input
+        msg = "invalid how option: foo"
+        with pytest.raises(ValueError, match=msg):
+            float_frame.dropna(how="foo")
+        # non-existent column - 8303
+        with pytest.raises(KeyError, match=r"^\['X'\]$"):
+            float_frame.dropna(subset=["A", "X"])
+
+    def test_dropna_multiple_axes(self):
+        df = DataFrame(
+            [
+                [1, np.nan, 2, 3],
+                [4, np.nan, 5, 6],
+                [np.nan, np.nan, np.nan, np.nan],
+                [7, np.nan, 8, 9],
+            ]
+        )
+
+        # GH20987
+        with pytest.raises(TypeError, match="supplying multiple axes"):
+            df.dropna(how="all", axis=[0, 1])
+        with pytest.raises(TypeError, match="supplying multiple axes"):
+            df.dropna(how="all", axis=(0, 1))
+
+        inp = df.copy()
+        with pytest.raises(TypeError, match="supplying multiple axes"):
+            inp.dropna(how="all", axis=(0, 1), inplace=True)
+
+    def test_dropna_tz_aware_datetime(self):
+        # GH13407
+        df = DataFrame()
+        dt1 = datetime.datetime(2015, 1, 1, tzinfo=dateutil.tz.tzutc())
+        dt2 = datetime.datetime(2015, 2, 2, tzinfo=dateutil.tz.tzutc())
+        df["Time"] = [dt1]
+        result = df.dropna(axis=0)
+        expected = DataFrame({"Time": [dt1]})
+        tm.assert_frame_equal(result, expected)
+
+        # Ex2
+        df = DataFrame({"Time": [dt1, None, np.nan, dt2]})
+        result = df.dropna(axis=0)
+        expected = DataFrame([dt1, dt2], columns=["Time"], index=[0, 3])
+        tm.assert_frame_equal(result, expected)
+
+    def test_dropna_categorical_interval_index(self):
+        # GH 25087
+        ii = pd.IntervalIndex.from_breaks([0, 2.78, 3.14, 6.28])
+        ci = pd.CategoricalIndex(ii)
+        df = DataFrame({"A": list("abc")}, index=ci)
+
+        expected = df
+        result = df.dropna()
+        tm.assert_frame_equal(result, expected)
+
+    def test_dropna_with_duplicate_columns(self):
+        df = DataFrame(
+            {
+                "A": np.random.default_rng(2).standard_normal(5),
+                "B": np.random.default_rng(2).standard_normal(5),
+                "C": np.random.default_rng(2).standard_normal(5),
+                "D": ["a", "b", "c", "d", "e"],
+            }
+        )
+        df.iloc[2, [0, 1, 2]] = np.nan
+        df.iloc[0, 0] = np.nan
+        df.iloc[1, 1] = np.nan
+        df.iloc[:, 3] = np.nan
+        expected = df.dropna(subset=["A", "B", "C"], how="all")
+        expected.columns = ["A", "A", "B", "C"]
+
+        df.columns = ["A", "A", "B", "C"]
+
+        result = df.dropna(subset=["A", "C"], how="all")
+        tm.assert_frame_equal(result, expected)
+
+    def test_set_single_column_subset(self):
+        # GH 41021
+        df = DataFrame({"A": [1, 2, 3], "B": list("abc"), "C": [4, np.nan, 5]})
+        expected = DataFrame(
+            {"A": [1, 3], "B": list("ac"), "C": [4.0, 5.0]}, index=[0, 2]
+        )
+        result = df.dropna(subset="C")
+        tm.assert_frame_equal(result, expected)
+
+    def test_single_column_not_present_in_axis(self):
+        # GH 41021
+        df = DataFrame({"A": [1, 2, 3]})
+
+        # Column not present
+        with pytest.raises(KeyError, match="['D']"):
+            df.dropna(subset="D", axis=0)
+
+    def test_subset_is_nparray(self):
+        # GH 41021
+        df = DataFrame({"A": [1, 2, np.nan], "B": list("abc"), "C": [4, np.nan, 5]})
+        expected = DataFrame({"A": [1.0], "B": ["a"], "C": [4.0]})
+        result = df.dropna(subset=np.array(["A", "C"]))
+        tm.assert_frame_equal(result, expected)
+
+    def test_no_nans_in_frame(self, axis):
+        # GH#41965
+        df = DataFrame([[1, 2], [3, 4]], columns=pd.RangeIndex(0, 2))
+        expected = df.copy()
+        result = df.dropna(axis=axis)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+    def test_how_thresh_param_incompatible(self):
+        # GH46575
+        df = DataFrame([1, 2, pd.NA])
+        msg = "You cannot set both the how and thresh arguments at the same time"
+        with pytest.raises(TypeError, match=msg):
+            df.dropna(how="all", thresh=2)
+
+        with pytest.raises(TypeError, match=msg):
+            df.dropna(how="any", thresh=2)
+
+        with pytest.raises(TypeError, match=msg):
+            df.dropna(how=None, thresh=None)
+
+    @pytest.mark.parametrize("val", [1, 1.5])
+    def test_dropna_ignore_index(self, val):
+        # GH#31725
+        df = DataFrame({"a": [1, 2, val]}, index=[3, 2, 1])
+        result = df.dropna(ignore_index=True)
+        expected = DataFrame({"a": [1, 2, val]})
+        tm.assert_frame_equal(result, expected)
+
+        df.dropna(ignore_index=True, inplace=True)
+        tm.assert_frame_equal(df, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dtypes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bdf16977dae685cb8a869a0efb21948c0a3561a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_dtypes.py
@@ -0,0 +1,150 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+    option_context,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameDataTypes:
+    def test_empty_frame_dtypes(self):
+        empty_df = DataFrame()
+        tm.assert_series_equal(empty_df.dtypes, Series(dtype=object))
+
+        nocols_df = DataFrame(index=[1, 2, 3])
+        tm.assert_series_equal(nocols_df.dtypes, Series(dtype=object))
+
+        norows_df = DataFrame(columns=list("abc"))
+        tm.assert_series_equal(norows_df.dtypes, Series(object, index=list("abc")))
+
+        norows_int_df = DataFrame(columns=list("abc")).astype(np.int32)
+        tm.assert_series_equal(
+            norows_int_df.dtypes, Series(np.dtype("int32"), index=list("abc"))
+        )
+
+        df = DataFrame({"a": 1, "b": True, "c": 1.0}, index=[1, 2, 3])
+        ex_dtypes = Series({"a": np.int64, "b": np.bool_, "c": np.float64})
+        tm.assert_series_equal(df.dtypes, ex_dtypes)
+
+        # same but for empty slice of df
+        tm.assert_series_equal(df[:0].dtypes, ex_dtypes)
+
+    def test_datetime_with_tz_dtypes(self):
+        tzframe = DataFrame(
+            {
+                "A": date_range("20130101", periods=3),
+                "B": date_range("20130101", periods=3, tz="US/Eastern"),
+                "C": date_range("20130101", periods=3, tz="CET"),
+            }
+        )
+        tzframe.iloc[1, 1] = pd.NaT
+        tzframe.iloc[1, 2] = pd.NaT
+        result = tzframe.dtypes.sort_index()
+        expected = Series(
+            [
+                np.dtype("datetime64[ns]"),
+                DatetimeTZDtype("ns", "US/Eastern"),
+                DatetimeTZDtype("ns", "CET"),
+            ],
+            ["A", "B", "C"],
+        )
+
+        tm.assert_series_equal(result, expected)
+
+    def test_dtypes_are_correct_after_column_slice(self):
+        # GH6525
+        df = DataFrame(index=range(5), columns=list("abc"), dtype=np.float64)
+        tm.assert_series_equal(
+            df.dtypes,
+            Series({"a": np.float64, "b": np.float64, "c": np.float64}),
+        )
+        tm.assert_series_equal(df.iloc[:, 2:].dtypes, Series({"c": np.float64}))
+        tm.assert_series_equal(
+            df.dtypes,
+            Series({"a": np.float64, "b": np.float64, "c": np.float64}),
+        )
+
+    @pytest.mark.parametrize(
+        "data",
+        [pd.NA, True],
+    )
+    def test_dtypes_are_correct_after_groupby_last(self, data):
+        # GH46409
+        df = DataFrame(
+            {"id": [1, 2, 3, 4], "test": [True, pd.NA, data, False]}
+        ).convert_dtypes()
+        result = df.groupby("id").last().test
+        expected = df.set_index("id").test
+        assert result.dtype == pd.BooleanDtype()
+        tm.assert_series_equal(expected, result)
+
+    def test_dtypes_gh8722(self, float_string_frame):
+        float_string_frame["bool"] = float_string_frame["A"] > 0
+        result = float_string_frame.dtypes
+        expected = Series(
+            {k: v.dtype for k, v in float_string_frame.items()}, index=result.index
+        )
+        tm.assert_series_equal(result, expected)
+
+        # compat, GH 8722
+        msg = "use_inf_as_na option is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            with option_context("use_inf_as_na", True):
+                df = DataFrame([[1]])
+                result = df.dtypes
+                tm.assert_series_equal(result, Series({0: np.dtype("int64")}))
+
+    def test_dtypes_timedeltas(self):
+        df = DataFrame(
+            {
+                "A": Series(date_range("2012-1-1", periods=3, freq="D")),
+                "B": Series([timedelta(days=i) for i in range(3)]),
+            }
+        )
+        result = df.dtypes
+        expected = Series(
+            [np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")], index=list("AB")
+        )
+        tm.assert_series_equal(result, expected)
+
+        df["C"] = df["A"] + df["B"]
+        result = df.dtypes
+        expected = Series(
+            [
+                np.dtype("datetime64[ns]"),
+                np.dtype("timedelta64[ns]"),
+                np.dtype("datetime64[ns]"),
+            ],
+            index=list("ABC"),
+        )
+        tm.assert_series_equal(result, expected)
+
+        # mixed int types
+        df["D"] = 1
+        result = df.dtypes
+        expected = Series(
+            [
+                np.dtype("datetime64[ns]"),
+                np.dtype("timedelta64[ns]"),
+                np.dtype("datetime64[ns]"),
+                np.dtype("int64"),
+            ],
+            index=list("ABCD"),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_frame_apply_np_array_return_type(self):
+        # GH 35517
+        df = DataFrame([["foo"]])
+        result = df.apply(lambda col: np.array("bar"))
+        expected = Series(["bar"])
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_duplicated.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_duplicated.py
new file mode 100644
index 0000000000000000000000000000000000000000..788aede8051100cab2558998daf700e8d77d66f9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_duplicated.py
@@ -0,0 +1,117 @@
+import re
+import sys
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("subset", ["a", ["a"], ["a", "B"]])
+def test_duplicated_with_misspelled_column_name(subset):
+    # GH 19730
+    df = DataFrame({"A": [0, 0, 1], "B": [0, 0, 1], "C": [0, 0, 1]})
+    msg = re.escape("Index(['a'], dtype='object')")
+
+    with pytest.raises(KeyError, match=msg):
+        df.duplicated(subset)
+
+
+def test_duplicated_implemented_no_recursion():
+    # gh-21524
+    # Ensure duplicated isn't implemented using recursion that
+    # can fail on wide frames
+    df = DataFrame(np.random.default_rng(2).integers(0, 1000, (10, 1000)))
+    rec_limit = sys.getrecursionlimit()
+    try:
+        sys.setrecursionlimit(100)
+        result = df.duplicated()
+    finally:
+        sys.setrecursionlimit(rec_limit)
+
+    # Then duplicates produce the bool Series as a result and don't fail during
+    # calculation. Actual values doesn't matter here, though usually it's all
+    # False in this case
+    assert isinstance(result, Series)
+    assert result.dtype == np.bool_
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True])),
+        ("last", Series([True, True, False, False, False])),
+        (False, Series([True, True, True, False, True])),
+    ],
+)
+def test_duplicated_keep(keep, expected):
+    df = DataFrame({"A": [0, 1, 1, 2, 0], "B": ["a", "b", "b", "c", "a"]})
+
+    result = df.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.xfail(reason="GH#21720; nan/None falsely considered equal")
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True])),
+        ("last", Series([True, True, False, False, False])),
+        (False, Series([True, True, True, False, True])),
+    ],
+)
+def test_duplicated_nan_none(keep, expected):
+    df = DataFrame({"C": [np.nan, 3, 3, None, np.nan], "x": 1}, dtype=object)
+
+    result = df.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("subset", [None, ["A", "B"], "A"])
+def test_duplicated_subset(subset, keep):
+    df = DataFrame(
+        {
+            "A": [0, 1, 1, 2, 0],
+            "B": ["a", "b", "b", "c", "a"],
+            "C": [np.nan, 3, 3, None, np.nan],
+        }
+    )
+
+    if subset is None:
+        subset = list(df.columns)
+    elif isinstance(subset, str):
+        # need to have a DataFrame, not a Series
+        # -> select columns with singleton list, not string
+        subset = [subset]
+
+    expected = df[subset].duplicated(keep=keep)
+    result = df.duplicated(keep=keep, subset=subset)
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicated_on_empty_frame():
+    # GH 25184
+
+    df = DataFrame(columns=["a", "b"])
+    dupes = df.duplicated("a")
+
+    result = df[dupes]
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_datetime64_duplicated():
+    dates = date_range("2010-07-01", end="2010-08-05")
+
+    tst = DataFrame({"symbol": "AAA", "date": dates})
+    result = tst.duplicated(["date", "symbol"])
+    assert (-result).all()
+
+    tst = DataFrame({"date": dates})
+    result = tst.date.duplicated()
+    assert (-result).all()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_equals.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_equals.py
new file mode 100644
index 0000000000000000000000000000000000000000..4028a26dfdc65f23e0ee63a8c88791b7a68d3291
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_equals.py
@@ -0,0 +1,85 @@
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestEquals:
+    def test_dataframe_not_equal(self):
+        # see GH#28839
+        df1 = DataFrame({"a": [1, 2], "b": ["s", "d"]})
+        df2 = DataFrame({"a": ["s", "d"], "b": [1, 2]})
+        assert df1.equals(df2) is False
+
+    def test_equals_different_blocks(self, using_array_manager):
+        # GH#9330
+        df0 = DataFrame({"A": ["x", "y"], "B": [1, 2], "C": ["w", "z"]})
+        df1 = df0.reset_index()[["A", "B", "C"]]
+        if not using_array_manager:
+            # this assert verifies that the above operations have
+            # induced a block rearrangement
+            assert df0._mgr.blocks[0].dtype != df1._mgr.blocks[0].dtype
+
+        # do the real tests
+        tm.assert_frame_equal(df0, df1)
+        assert df0.equals(df1)
+        assert df1.equals(df0)
+
+    def test_equals(self):
+        # Add object dtype column with nans
+        index = np.random.default_rng(2).random(10)
+        df1 = DataFrame(
+            np.random.default_rng(2).random(10), index=index, columns=["floats"]
+        )
+        df1["text"] = "the sky is so blue. we could use more chocolate.".split()
+        df1["start"] = date_range("2000-1-1", periods=10, freq="T")
+        df1["end"] = date_range("2000-1-1", periods=10, freq="D")
+        df1["diff"] = df1["end"] - df1["start"]
+        # Explicitly cast to object, to avoid implicit cast when setting np.nan
+        df1["bool"] = (np.arange(10) % 3 == 0).astype(object)
+        df1.loc[::2] = np.nan
+        df2 = df1.copy()
+        assert df1["text"].equals(df2["text"])
+        assert df1["start"].equals(df2["start"])
+        assert df1["end"].equals(df2["end"])
+        assert df1["diff"].equals(df2["diff"])
+        assert df1["bool"].equals(df2["bool"])
+        assert df1.equals(df2)
+        assert not df1.equals(object)
+
+        # different dtype
+        different = df1.copy()
+        different["floats"] = different["floats"].astype("float32")
+        assert not df1.equals(different)
+
+        # different index
+        different_index = -index
+        different = df2.set_index(different_index)
+        assert not df1.equals(different)
+
+        # different columns
+        different = df2.copy()
+        different.columns = df2.columns[::-1]
+        assert not df1.equals(different)
+
+        # DatetimeIndex
+        index = date_range("2000-1-1", periods=10, freq="T")
+        df1 = df1.set_index(index)
+        df2 = df1.copy()
+        assert df1.equals(df2)
+
+        # MultiIndex
+        df3 = df1.set_index(["text"], append=True)
+        df2 = df1.set_index(["text"], append=True)
+        assert df3.equals(df2)
+
+        df2 = df1.set_index(["floats"], append=True)
+        assert not df3.equals(df2)
+
+        # NaN in index
+        df3 = df1.set_index(["floats"], append=True)
+        df2 = df1.set_index(["floats"], append=True)
+        assert df3.equals(df2)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_explode.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_explode.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1e4a603c5710d7356313741198862a0349a26e3
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_explode.py
@@ -0,0 +1,303 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_error():
+    df = pd.DataFrame(
+        {"A": pd.Series([[0, 1, 2], np.nan, [], (3, 4)], index=list("abcd")), "B": 1}
+    )
+    with pytest.raises(
+        ValueError, match="column must be a scalar, tuple, or list thereof"
+    ):
+        df.explode([list("AA")])
+
+    with pytest.raises(ValueError, match="column must be unique"):
+        df.explode(list("AA"))
+
+    df.columns = list("AA")
+    with pytest.raises(
+        ValueError,
+        match=re.escape("DataFrame columns must be unique. Duplicate columns: ['A']"),
+    ):
+        df.explode("A")
+
+
+@pytest.mark.parametrize(
+    "input_subset, error_message",
+    [
+        (
+            list("AC"),
+            "columns must have matching element counts",
+        ),
+        (
+            [],
+            "column must be nonempty",
+        ),
+        (
+            list("AC"),
+            "columns must have matching element counts",
+        ),
+    ],
+)
+def test_error_multi_columns(input_subset, error_message):
+    # GH 39240
+    df = pd.DataFrame(
+        {
+            "A": [[0, 1, 2], np.nan, [], (3, 4)],
+            "B": 1,
+            "C": [["a", "b", "c"], "foo", [], ["d", "e", "f"]],
+        },
+        index=list("abcd"),
+    )
+    with pytest.raises(ValueError, match=error_message):
+        df.explode(input_subset)
+
+
+@pytest.mark.parametrize(
+    "scalar",
+    ["a", 0, 1.5, pd.Timedelta("1 days"), pd.Timestamp("2019-12-31")],
+)
+def test_basic(scalar):
+    df = pd.DataFrame(
+        {scalar: pd.Series([[0, 1, 2], np.nan, [], (3, 4)], index=list("abcd")), "B": 1}
+    )
+    result = df.explode(scalar)
+    expected = pd.DataFrame(
+        {
+            scalar: pd.Series(
+                [0, 1, 2, np.nan, np.nan, 3, 4], index=list("aaabcdd"), dtype=object
+            ),
+            "B": 1,
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_multi_index_rows():
+    df = pd.DataFrame(
+        {"A": np.array([[0, 1, 2], np.nan, [], (3, 4)], dtype=object), "B": 1},
+        index=pd.MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1), ("b", 2)]),
+    )
+
+    result = df.explode("A")
+    expected = pd.DataFrame(
+        {
+            "A": pd.Series(
+                [0, 1, 2, np.nan, np.nan, 3, 4],
+                index=pd.MultiIndex.from_tuples(
+                    [
+                        ("a", 1),
+                        ("a", 1),
+                        ("a", 1),
+                        ("a", 2),
+                        ("b", 1),
+                        ("b", 2),
+                        ("b", 2),
+                    ]
+                ),
+                dtype=object,
+            ),
+            "B": 1,
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_multi_index_columns():
+    df = pd.DataFrame(
+        {("A", 1): np.array([[0, 1, 2], np.nan, [], (3, 4)], dtype=object), ("A", 2): 1}
+    )
+
+    result = df.explode(("A", 1))
+    expected = pd.DataFrame(
+        {
+            ("A", 1): pd.Series(
+                [0, 1, 2, np.nan, np.nan, 3, 4],
+                index=pd.Index([0, 0, 0, 1, 2, 3, 3]),
+                dtype=object,
+            ),
+            ("A", 2): 1,
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecase():
+    # explode a single column
+    # gh-10511
+    df = pd.DataFrame(
+        [[11, range(5), 10], [22, range(3), 20]], columns=list("ABC")
+    ).set_index("C")
+    result = df.explode("B")
+
+    expected = pd.DataFrame(
+        {
+            "A": [11, 11, 11, 11, 11, 22, 22, 22],
+            "B": np.array([0, 1, 2, 3, 4, 0, 1, 2], dtype=object),
+            "C": [10, 10, 10, 10, 10, 20, 20, 20],
+        },
+        columns=list("ABC"),
+    ).set_index("C")
+
+    tm.assert_frame_equal(result, expected)
+
+    # gh-8517
+    df = pd.DataFrame(
+        [["2014-01-01", "Alice", "A B"], ["2014-01-02", "Bob", "C D"]],
+        columns=["dt", "name", "text"],
+    )
+    result = df.assign(text=df.text.str.split(" ")).explode("text")
+    expected = pd.DataFrame(
+        [
+            ["2014-01-01", "Alice", "A"],
+            ["2014-01-01", "Alice", "B"],
+            ["2014-01-02", "Bob", "C"],
+            ["2014-01-02", "Bob", "D"],
+        ],
+        columns=["dt", "name", "text"],
+        index=[0, 0, 1, 1],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "input_dict, input_index, expected_dict, expected_index",
+    [
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            [0, 0],
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            [0, 0, 0, 0],
+        ),
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            pd.Index([0, 0], name="my_index"),
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            pd.Index([0, 0, 0, 0], name="my_index"),
+        ),
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            pd.MultiIndex.from_arrays(
+                [[0, 0], [1, 1]], names=["my_first_index", "my_second_index"]
+            ),
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            pd.MultiIndex.from_arrays(
+                [[0, 0, 0, 0], [1, 1, 1, 1]],
+                names=["my_first_index", "my_second_index"],
+            ),
+        ),
+        (
+            {"col1": [[1, 2], [3, 4]], "col2": ["foo", "bar"]},
+            pd.MultiIndex.from_arrays([[0, 0], [1, 1]], names=["my_index", None]),
+            {"col1": [1, 2, 3, 4], "col2": ["foo", "foo", "bar", "bar"]},
+            pd.MultiIndex.from_arrays(
+                [[0, 0, 0, 0], [1, 1, 1, 1]], names=["my_index", None]
+            ),
+        ),
+    ],
+)
+def test_duplicate_index(input_dict, input_index, expected_dict, expected_index):
+    # GH 28005
+    df = pd.DataFrame(input_dict, index=input_index)
+    result = df.explode("col1")
+    expected = pd.DataFrame(expected_dict, index=expected_index, dtype=object)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_ignore_index():
+    # GH 34932
+    df = pd.DataFrame({"id": range(0, 20, 10), "values": [list("ab"), list("cd")]})
+    result = df.explode("values", ignore_index=True)
+    expected = pd.DataFrame(
+        {"id": [0, 0, 10, 10], "values": list("abcd")}, index=[0, 1, 2, 3]
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_explode_sets():
+    # https://github.com/pandas-dev/pandas/issues/35614
+    df = pd.DataFrame({"a": [{"x", "y"}], "b": [1]}, index=[1])
+    result = df.explode(column="a").sort_values(by="a")
+    expected = pd.DataFrame({"a": ["x", "y"], "b": [1, 1]}, index=[1, 1])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "input_subset, expected_dict, expected_index",
+    [
+        (
+            list("AC"),
+            {
+                "A": pd.Series(
+                    [0, 1, 2, np.nan, np.nan, 3, 4, np.nan],
+                    index=list("aaabcdde"),
+                    dtype=object,
+                ),
+                "B": 1,
+                "C": ["a", "b", "c", "foo", np.nan, "d", "e", np.nan],
+            },
+            list("aaabcdde"),
+        ),
+        (
+            list("A"),
+            {
+                "A": pd.Series(
+                    [0, 1, 2, np.nan, np.nan, 3, 4, np.nan],
+                    index=list("aaabcdde"),
+                    dtype=object,
+                ),
+                "B": 1,
+                "C": [
+                    ["a", "b", "c"],
+                    ["a", "b", "c"],
+                    ["a", "b", "c"],
+                    "foo",
+                    [],
+                    ["d", "e"],
+                    ["d", "e"],
+                    np.nan,
+                ],
+            },
+            list("aaabcdde"),
+        ),
+    ],
+)
+def test_multi_columns(input_subset, expected_dict, expected_index):
+    # GH 39240
+    df = pd.DataFrame(
+        {
+            "A": [[0, 1, 2], np.nan, [], (3, 4), np.nan],
+            "B": 1,
+            "C": [["a", "b", "c"], "foo", [], ["d", "e"], np.nan],
+        },
+        index=list("abcde"),
+    )
+    result = df.explode(input_subset)
+    expected = pd.DataFrame(expected_dict, expected_index)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_multi_columns_nan_empty():
+    # GH 46084
+    df = pd.DataFrame(
+        {
+            "A": [[0, 1], [5], [], [2, 3]],
+            "B": [9, 8, 7, 6],
+            "C": [[1, 2], np.nan, [], [3, 4]],
+        }
+    )
+    result = df.explode(["A", "C"])
+    expected = pd.DataFrame(
+        {
+            "A": np.array([0, 1, 5, np.nan, 2, 3], dtype=object),
+            "B": [9, 9, 8, 7, 6, 6],
+            "C": np.array([1, 2, np.nan, np.nan, 3, 4], dtype=object),
+        },
+        index=[0, 0, 1, 2, 3, 3],
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_fillna.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_fillna.py
new file mode 100644
index 0000000000000000000000000000000000000000..812150bb860e93db476a188260ddc3a94b90e7d5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_fillna.py
@@ -0,0 +1,832 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    NaT,
+    PeriodIndex,
+    Series,
+    TimedeltaIndex,
+    Timestamp,
+    date_range,
+    to_datetime,
+)
+import pandas._testing as tm
+from pandas.tests.frame.common import _check_mixed_float
+
+
+class TestFillNA:
+    def test_fillna_dict_inplace_nonunique_columns(self, using_copy_on_write):
+        df = DataFrame(
+            {"A": [np.nan] * 3, "B": [NaT, Timestamp(1), NaT], "C": [np.nan, "foo", 2]}
+        )
+        df.columns = ["A", "A", "A"]
+        orig = df[:]
+
+        df.fillna({"A": 2}, inplace=True)
+        # The first and third columns can be set inplace, while the second cannot.
+
+        expected = DataFrame(
+            {"A": [2.0] * 3, "B": [2, Timestamp(1), 2], "C": [2, "foo", 2]}
+        )
+        expected.columns = ["A", "A", "A"]
+        tm.assert_frame_equal(df, expected)
+
+        # TODO: what's the expected/desired behavior with CoW?
+        if not using_copy_on_write:
+            assert tm.shares_memory(df.iloc[:, 0], orig.iloc[:, 0])
+        assert not tm.shares_memory(df.iloc[:, 1], orig.iloc[:, 1])
+        if not using_copy_on_write:
+            assert tm.shares_memory(df.iloc[:, 2], orig.iloc[:, 2])
+
+    @td.skip_array_manager_not_yet_implemented
+    def test_fillna_on_column_view(self, using_copy_on_write):
+        # GH#46149 avoid unnecessary copies
+        arr = np.full((40, 50), np.nan)
+        df = DataFrame(arr, copy=False)
+
+        if using_copy_on_write:
+            with tm.raises_chained_assignment_error():
+                df[0].fillna(-1, inplace=True)
+            assert np.isnan(arr[:, 0]).all()
+        else:
+            df[0].fillna(-1, inplace=True)
+            assert (arr[:, 0] == -1).all()
+
+        # i.e. we didn't create a new 49-column block
+        assert len(df._mgr.arrays) == 1
+        assert np.shares_memory(df.values, arr)
+
+    def test_fillna_datetime(self, datetime_frame):
+        tf = datetime_frame
+        tf.loc[tf.index[:5], "A"] = np.nan
+        tf.loc[tf.index[-5:], "A"] = np.nan
+
+        zero_filled = datetime_frame.fillna(0)
+        assert (zero_filled.loc[zero_filled.index[:5], "A"] == 0).all()
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            padded = datetime_frame.fillna(method="pad")
+        assert np.isnan(padded.loc[padded.index[:5], "A"]).all()
+        assert (
+            padded.loc[padded.index[-5:], "A"] == padded.loc[padded.index[-5], "A"]
+        ).all()
+
+        msg = "Must specify a fill 'value' or 'method'"
+        with pytest.raises(ValueError, match=msg):
+            datetime_frame.fillna()
+        msg = "Cannot specify both 'value' and 'method'"
+        with pytest.raises(ValueError, match=msg):
+            datetime_frame.fillna(5, method="ffill")
+
+    def test_fillna_mixed_type(self, float_string_frame):
+        mf = float_string_frame
+        mf.loc[mf.index[5:20], "foo"] = np.nan
+        mf.loc[mf.index[-10:], "A"] = np.nan
+        # TODO: make stronger assertion here, GH 25640
+        mf.fillna(value=0)
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            mf.fillna(method="pad")
+
+    def test_fillna_mixed_float(self, mixed_float_frame):
+        # mixed numeric (but no float16)
+        mf = mixed_float_frame.reindex(columns=["A", "B", "D"])
+        mf.loc[mf.index[-10:], "A"] = np.nan
+        result = mf.fillna(value=0)
+        _check_mixed_float(result, dtype={"C": None})
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = mf.fillna(method="pad")
+        _check_mixed_float(result, dtype={"C": None})
+
+    def test_fillna_empty(self, using_copy_on_write):
+        if using_copy_on_write:
+            pytest.skip("condition is unnecessary complex and is deprecated anyway")
+        # empty frame (GH#2778)
+        df = DataFrame(columns=["x"])
+        for m in ["pad", "backfill"]:
+            msg = "Series.fillna with 'method' is deprecated"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                df.x.fillna(method=m, inplace=True)
+                df.x.fillna(method=m)
+
+    def test_fillna_different_dtype(self):
+        # with different dtype (GH#3386)
+        df = DataFrame(
+            [["a", "a", np.nan, "a"], ["b", "b", np.nan, "b"], ["c", "c", np.nan, "c"]]
+        )
+
+        result = df.fillna({2: "foo"})
+        expected = DataFrame(
+            [["a", "a", "foo", "a"], ["b", "b", "foo", "b"], ["c", "c", "foo", "c"]]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        return_value = df.fillna({2: "foo"}, inplace=True)
+        tm.assert_frame_equal(df, expected)
+        assert return_value is None
+
+    def test_fillna_limit_and_value(self):
+        # limit and value
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 3)))
+        df.iloc[2:7, 0] = np.nan
+        df.iloc[3:5, 2] = np.nan
+
+        expected = df.copy()
+        expected.iloc[2, 0] = 999
+        expected.iloc[3, 2] = 999
+        result = df.fillna(999, limit=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_datelike(self):
+        # with datelike
+        # GH#6344
+        df = DataFrame(
+            {
+                "Date": [NaT, Timestamp("2014-1-1")],
+                "Date2": [Timestamp("2013-1-1"), NaT],
+            }
+        )
+
+        expected = df.copy()
+        expected["Date"] = expected["Date"].fillna(df.loc[df.index[0], "Date2"])
+        result = df.fillna(value={"Date": df["Date2"]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_tzaware(self):
+        # with timezone
+        # GH#15855
+        df = DataFrame({"A": [Timestamp("2012-11-11 00:00:00+01:00"), NaT]})
+        exp = DataFrame(
+            {
+                "A": [
+                    Timestamp("2012-11-11 00:00:00+01:00"),
+                    Timestamp("2012-11-11 00:00:00+01:00"),
+                ]
+            }
+        )
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df.fillna(method="pad")
+        tm.assert_frame_equal(res, exp)
+
+        df = DataFrame({"A": [NaT, Timestamp("2012-11-11 00:00:00+01:00")]})
+        exp = DataFrame(
+            {
+                "A": [
+                    Timestamp("2012-11-11 00:00:00+01:00"),
+                    Timestamp("2012-11-11 00:00:00+01:00"),
+                ]
+            }
+        )
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df.fillna(method="bfill")
+        tm.assert_frame_equal(res, exp)
+
+    def test_fillna_tzaware_different_column(self):
+        # with timezone in another column
+        # GH#15522
+        df = DataFrame(
+            {
+                "A": date_range("20130101", periods=4, tz="US/Eastern"),
+                "B": [1, 2, np.nan, np.nan],
+            }
+        )
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.fillna(method="pad")
+        expected = DataFrame(
+            {
+                "A": date_range("20130101", periods=4, tz="US/Eastern"),
+                "B": [1.0, 2.0, 2.0, 2.0],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_na_actions_categorical(self):
+        cat = Categorical([1, 2, 3, np.nan], categories=[1, 2, 3])
+        vals = ["a", "b", np.nan, "d"]
+        df = DataFrame({"cats": cat, "vals": vals})
+        cat2 = Categorical([1, 2, 3, 3], categories=[1, 2, 3])
+        vals2 = ["a", "b", "b", "d"]
+        df_exp_fill = DataFrame({"cats": cat2, "vals": vals2})
+        cat3 = Categorical([1, 2, 3], categories=[1, 2, 3])
+        vals3 = ["a", "b", np.nan]
+        df_exp_drop_cats = DataFrame({"cats": cat3, "vals": vals3})
+        cat4 = Categorical([1, 2], categories=[1, 2, 3])
+        vals4 = ["a", "b"]
+        df_exp_drop_all = DataFrame({"cats": cat4, "vals": vals4})
+
+        # fillna
+        res = df.fillna(value={"cats": 3, "vals": "b"})
+        tm.assert_frame_equal(res, df_exp_fill)
+
+        msg = "Cannot setitem on a Categorical with a new category"
+        with pytest.raises(TypeError, match=msg):
+            df.fillna(value={"cats": 4, "vals": "c"})
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df.fillna(method="pad")
+        tm.assert_frame_equal(res, df_exp_fill)
+
+        # dropna
+        res = df.dropna(subset=["cats"])
+        tm.assert_frame_equal(res, df_exp_drop_cats)
+
+        res = df.dropna()
+        tm.assert_frame_equal(res, df_exp_drop_all)
+
+        # make sure that fillna takes missing values into account
+        c = Categorical([np.nan, "b", np.nan], categories=["a", "b"])
+        df = DataFrame({"cats": c, "vals": [1, 2, 3]})
+
+        cat_exp = Categorical(["a", "b", "a"], categories=["a", "b"])
+        df_exp = DataFrame({"cats": cat_exp, "vals": [1, 2, 3]})
+
+        res = df.fillna("a")
+        tm.assert_frame_equal(res, df_exp)
+
+    def test_fillna_categorical_nan(self):
+        # GH#14021
+        # np.nan should always be a valid filler
+        cat = Categorical([np.nan, 2, np.nan])
+        val = Categorical([np.nan, np.nan, np.nan])
+        df = DataFrame({"cats": cat, "vals": val})
+
+        # GH#32950 df.median() is poorly behaved because there is no
+        #  Categorical.median
+        median = Series({"cats": 2.0, "vals": np.nan})
+
+        res = df.fillna(median)
+        v_exp = [np.nan, np.nan, np.nan]
+        df_exp = DataFrame({"cats": [2, 2, 2], "vals": v_exp}, dtype="category")
+        tm.assert_frame_equal(res, df_exp)
+
+        result = df.cats.fillna(np.nan)
+        tm.assert_series_equal(result, df.cats)
+
+        result = df.vals.fillna(np.nan)
+        tm.assert_series_equal(result, df.vals)
+
+        idx = DatetimeIndex(
+            ["2011-01-01 09:00", "2016-01-01 23:45", "2011-01-01 09:00", NaT, NaT]
+        )
+        df = DataFrame({"a": Categorical(idx)})
+        tm.assert_frame_equal(df.fillna(value=NaT), df)
+
+        idx = PeriodIndex(["2011-01", "2011-01", "2011-01", NaT, NaT], freq="M")
+        df = DataFrame({"a": Categorical(idx)})
+        tm.assert_frame_equal(df.fillna(value=NaT), df)
+
+        idx = TimedeltaIndex(["1 days", "2 days", "1 days", NaT, NaT])
+        df = DataFrame({"a": Categorical(idx)})
+        tm.assert_frame_equal(df.fillna(value=NaT), df)
+
+    def test_fillna_downcast(self):
+        # GH#15277
+        # infer int64 from float64
+        df = DataFrame({"a": [1.0, np.nan]})
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.fillna(0, downcast="infer")
+        expected = DataFrame({"a": [1, 0]})
+        tm.assert_frame_equal(result, expected)
+
+        # infer int64 from float64 when fillna value is a dict
+        df = DataFrame({"a": [1.0, np.nan]})
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.fillna({"a": 0}, downcast="infer")
+        expected = DataFrame({"a": [1, 0]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_downcast_false(self, frame_or_series):
+        # GH#45603 preserve object dtype with downcast=False
+        obj = frame_or_series([1, 2, 3], dtype="object")
+        msg = "The 'downcast' keyword in fillna"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = obj.fillna("", downcast=False)
+        tm.assert_equal(result, obj)
+
+    def test_fillna_downcast_noop(self, frame_or_series):
+        # GH#45423
+        # Two relevant paths:
+        #  1) not _can_hold_na (e.g. integer)
+        #  2) _can_hold_na + noop + not can_hold_element
+
+        obj = frame_or_series([1, 2, 3], dtype=np.int64)
+
+        msg = "The 'downcast' keyword in fillna"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            # GH#40988
+            res = obj.fillna("foo", downcast=np.dtype(np.int32))
+        expected = obj.astype(np.int32)
+        tm.assert_equal(res, expected)
+
+        obj2 = obj.astype(np.float64)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res2 = obj2.fillna("foo", downcast="infer")
+        expected2 = obj  # get back int64
+        tm.assert_equal(res2, expected2)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            # GH#40988
+            res3 = obj2.fillna("foo", downcast=np.dtype(np.int32))
+        tm.assert_equal(res3, expected)
+
+    @pytest.mark.parametrize("columns", [["A", "A", "B"], ["A", "A"]])
+    def test_fillna_dictlike_value_duplicate_colnames(self, columns):
+        # GH#43476
+        df = DataFrame(np.nan, index=[0, 1], columns=columns)
+        with tm.assert_produces_warning(None):
+            result = df.fillna({"A": 0})
+
+        expected = df.copy()
+        expected["A"] = 0.0
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_dtype_conversion(self):
+        # make sure that fillna on an empty frame works
+        df = DataFrame(index=["A", "B", "C"], columns=[1, 2, 3, 4, 5])
+        result = df.dtypes
+        expected = Series([np.dtype("object")] * 5, index=[1, 2, 3, 4, 5])
+        tm.assert_series_equal(result, expected)
+
+        result = df.fillna(1)
+        expected = DataFrame(1, index=["A", "B", "C"], columns=[1, 2, 3, 4, 5])
+        tm.assert_frame_equal(result, expected)
+
+        # empty block
+        df = DataFrame(index=range(3), columns=["A", "B"], dtype="float64")
+        result = df.fillna("nan")
+        expected = DataFrame("nan", index=range(3), columns=["A", "B"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("val", ["", 1, np.nan, 1.0])
+    def test_fillna_dtype_conversion_equiv_replace(self, val):
+        df = DataFrame({"A": [1, np.nan], "B": [1.0, 2.0]})
+        expected = df.replace(np.nan, val)
+        result = df.fillna(val)
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_datetime_columns(self):
+        # GH#7095
+        df = DataFrame(
+            {
+                "A": [-1, -2, np.nan],
+                "B": date_range("20130101", periods=3),
+                "C": ["foo", "bar", None],
+                "D": ["foo2", "bar2", None],
+            },
+            index=date_range("20130110", periods=3),
+        )
+        result = df.fillna("?")
+        expected = DataFrame(
+            {
+                "A": [-1, -2, "?"],
+                "B": date_range("20130101", periods=3),
+                "C": ["foo", "bar", "?"],
+                "D": ["foo2", "bar2", "?"],
+            },
+            index=date_range("20130110", periods=3),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            {
+                "A": [-1, -2, np.nan],
+                "B": [Timestamp("2013-01-01"), Timestamp("2013-01-02"), NaT],
+                "C": ["foo", "bar", None],
+                "D": ["foo2", "bar2", None],
+            },
+            index=date_range("20130110", periods=3),
+        )
+        result = df.fillna("?")
+        expected = DataFrame(
+            {
+                "A": [-1, -2, "?"],
+                "B": [Timestamp("2013-01-01"), Timestamp("2013-01-02"), "?"],
+                "C": ["foo", "bar", "?"],
+                "D": ["foo2", "bar2", "?"],
+            },
+            index=date_range("20130110", periods=3),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_ffill(self, datetime_frame):
+        datetime_frame.loc[datetime_frame.index[:5], "A"] = np.nan
+        datetime_frame.loc[datetime_frame.index[-5:], "A"] = np.nan
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            alt = datetime_frame.fillna(method="ffill")
+        tm.assert_frame_equal(datetime_frame.ffill(), alt)
+
+    def test_bfill(self, datetime_frame):
+        datetime_frame.loc[datetime_frame.index[:5], "A"] = np.nan
+        datetime_frame.loc[datetime_frame.index[-5:], "A"] = np.nan
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            alt = datetime_frame.fillna(method="bfill")
+
+        tm.assert_frame_equal(datetime_frame.bfill(), alt)
+
+    def test_frame_pad_backfill_limit(self):
+        index = np.arange(10)
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)), index=index)
+
+        result = df[:2].reindex(index, method="pad", limit=5)
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df[:2].reindex(index).fillna(method="pad")
+        expected.iloc[-3:] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+        result = df[-2:].reindex(index, method="backfill", limit=5)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df[-2:].reindex(index).fillna(method="backfill")
+        expected.iloc[:3] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_fillna_limit(self):
+        index = np.arange(10)
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)), index=index)
+
+        result = df[:2].reindex(index)
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = result.fillna(method="pad", limit=5)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df[:2].reindex(index).fillna(method="pad")
+        expected.iloc[-3:] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+        result = df[-2:].reindex(index)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = result.fillna(method="backfill", limit=5)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df[-2:].reindex(index).fillna(method="backfill")
+        expected.iloc[:3] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_skip_certain_blocks(self):
+        # don't try to fill boolean, int blocks
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)).astype(int))
+
+        # it works!
+        df.fillna(np.nan)
+
+    @pytest.mark.parametrize("type", [int, float])
+    def test_fillna_positive_limit(self, type):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4))).astype(type)
+
+        msg = "Limit must be greater than 0"
+        with pytest.raises(ValueError, match=msg):
+            df.fillna(0, limit=-5)
+
+    @pytest.mark.parametrize("type", [int, float])
+    def test_fillna_integer_limit(self, type):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4))).astype(type)
+
+        msg = "Limit must be an integer"
+        with pytest.raises(ValueError, match=msg):
+            df.fillna(0, limit=0.5)
+
+    def test_fillna_inplace(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+        df.loc[:4, 1] = np.nan
+        df.loc[-4:, 3] = np.nan
+
+        expected = df.fillna(value=0)
+        assert expected is not df
+
+        df.fillna(value=0, inplace=True)
+        tm.assert_frame_equal(df, expected)
+
+        expected = df.fillna(value={0: 0}, inplace=True)
+        assert expected is None
+
+        df.loc[:4, 1] = np.nan
+        df.loc[-4:, 3] = np.nan
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df.fillna(method="ffill")
+        assert expected is not df
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            df.fillna(method="ffill", inplace=True)
+        tm.assert_frame_equal(df, expected)
+
+    def test_fillna_dict_series(self):
+        df = DataFrame(
+            {
+                "a": [np.nan, 1, 2, np.nan, np.nan],
+                "b": [1, 2, 3, np.nan, np.nan],
+                "c": [np.nan, 1, 2, 3, 4],
+            }
+        )
+
+        result = df.fillna({"a": 0, "b": 5})
+
+        expected = df.copy()
+        expected["a"] = expected["a"].fillna(0)
+        expected["b"] = expected["b"].fillna(5)
+        tm.assert_frame_equal(result, expected)
+
+        # it works
+        result = df.fillna({"a": 0, "b": 5, "d": 7})
+
+        # Series treated same as dict
+        result = df.fillna(df.max())
+        expected = df.fillna(df.max().to_dict())
+        tm.assert_frame_equal(result, expected)
+
+        # disable this for now
+        with pytest.raises(NotImplementedError, match="column by column"):
+            df.fillna(df.max(1), axis=1)
+
+    def test_fillna_dataframe(self):
+        # GH#8377
+        df = DataFrame(
+            {
+                "a": [np.nan, 1, 2, np.nan, np.nan],
+                "b": [1, 2, 3, np.nan, np.nan],
+                "c": [np.nan, 1, 2, 3, 4],
+            },
+            index=list("VWXYZ"),
+        )
+
+        # df2 may have different index and columns
+        df2 = DataFrame(
+            {
+                "a": [np.nan, 10, 20, 30, 40],
+                "b": [50, 60, 70, 80, 90],
+                "foo": ["bar"] * 5,
+            },
+            index=list("VWXuZ"),
+        )
+
+        result = df.fillna(df2)
+
+        # only those columns and indices which are shared get filled
+        expected = DataFrame(
+            {
+                "a": [np.nan, 1, 2, np.nan, 40],
+                "b": [1, 2, 3, np.nan, 90],
+                "c": [np.nan, 1, 2, 3, 4],
+            },
+            index=list("VWXYZ"),
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_columns(self):
+        arr = np.random.default_rng(2).standard_normal((10, 10))
+        arr[:, ::2] = np.nan
+        df = DataFrame(arr)
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.fillna(method="ffill", axis=1)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df.T.fillna(method="pad").T
+        tm.assert_frame_equal(result, expected)
+
+        df.insert(6, "foo", 5)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.fillna(method="ffill", axis=1)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected = df.astype(float).fillna(method="ffill", axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_invalid_method(self, float_frame):
+        with pytest.raises(ValueError, match="ffil"):
+            float_frame.fillna(method="ffil")
+
+    def test_fillna_invalid_value(self, float_frame):
+        # list
+        msg = '"value" parameter must be a scalar or dict, but you passed a "{}"'
+        with pytest.raises(TypeError, match=msg.format("list")):
+            float_frame.fillna([1, 2])
+        # tuple
+        with pytest.raises(TypeError, match=msg.format("tuple")):
+            float_frame.fillna((1, 2))
+        # frame with series
+        msg = (
+            '"value" parameter must be a scalar, dict or Series, but you '
+            'passed a "DataFrame"'
+        )
+        with pytest.raises(TypeError, match=msg):
+            float_frame.iloc[:, 0].fillna(float_frame)
+
+    def test_fillna_col_reordering(self):
+        cols = ["COL." + str(i) for i in range(5, 0, -1)]
+        data = np.random.default_rng(2).random((20, 5))
+        df = DataFrame(index=range(20), columns=cols, data=data)
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            filled = df.fillna(method="ffill")
+        assert df.columns.tolist() == filled.columns.tolist()
+
+    def test_fill_corner(self, float_frame, float_string_frame):
+        mf = float_string_frame
+        mf.loc[mf.index[5:20], "foo"] = np.nan
+        mf.loc[mf.index[-10:], "A"] = np.nan
+
+        filled = float_string_frame.fillna(value=0)
+        assert (filled.loc[filled.index[5:20], "foo"] == 0).all()
+        del float_string_frame["foo"]
+
+        float_frame.reindex(columns=[]).fillna(value=0)
+
+    def test_fillna_downcast_dict(self):
+        # GH#40809
+        df = DataFrame({"col1": [1, np.nan]})
+
+        msg = "The 'downcast' keyword in fillna"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.fillna({"col1": 2}, downcast={"col1": "int64"})
+        expected = DataFrame({"col1": [1, 2]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_with_columns_and_limit(self):
+        # GH40989
+        df = DataFrame(
+            [
+                [np.nan, 2, np.nan, 0],
+                [3, 4, np.nan, 1],
+                [np.nan, np.nan, np.nan, 5],
+                [np.nan, 3, np.nan, 4],
+            ],
+            columns=list("ABCD"),
+        )
+        result = df.fillna(axis=1, value=100, limit=1)
+        result2 = df.fillna(axis=1, value=100, limit=2)
+
+        expected = DataFrame(
+            {
+                "A": Series([100, 3, 100, 100], dtype="float64"),
+                "B": [2, 4, np.nan, 3],
+                "C": [np.nan, 100, np.nan, np.nan],
+                "D": Series([0, 1, 5, 4], dtype="float64"),
+            },
+            index=[0, 1, 2, 3],
+        )
+        expected2 = DataFrame(
+            {
+                "A": Series([100, 3, 100, 100], dtype="float64"),
+                "B": Series([2, 4, 100, 3], dtype="float64"),
+                "C": [100, 100, np.nan, 100],
+                "D": Series([0, 1, 5, 4], dtype="float64"),
+            },
+            index=[0, 1, 2, 3],
+        )
+
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected2)
+
+    def test_fillna_datetime_inplace(self):
+        # GH#48863
+        df = DataFrame(
+            {
+                "date1": to_datetime(["2018-05-30", None]),
+                "date2": to_datetime(["2018-09-30", None]),
+            }
+        )
+        expected = df.copy()
+        df.fillna(np.nan, inplace=True)
+        tm.assert_frame_equal(df, expected)
+
+    def test_fillna_inplace_with_columns_limit_and_value(self):
+        # GH40989
+        df = DataFrame(
+            [
+                [np.nan, 2, np.nan, 0],
+                [3, 4, np.nan, 1],
+                [np.nan, np.nan, np.nan, 5],
+                [np.nan, 3, np.nan, 4],
+            ],
+            columns=list("ABCD"),
+        )
+
+        expected = df.fillna(axis=1, value=100, limit=1)
+        assert expected is not df
+
+        df.fillna(axis=1, value=100, limit=1, inplace=True)
+        tm.assert_frame_equal(df, expected)
+
+    @td.skip_array_manager_invalid_test
+    @pytest.mark.parametrize("val", [-1, {"x": -1, "y": -1}])
+    def test_inplace_dict_update_view(self, val, using_copy_on_write):
+        # GH#47188
+        df = DataFrame({"x": [np.nan, 2], "y": [np.nan, 2]})
+        df_orig = df.copy()
+        result_view = df[:]
+        df.fillna(val, inplace=True)
+        expected = DataFrame({"x": [-1, 2.0], "y": [-1.0, 2]})
+        tm.assert_frame_equal(df, expected)
+        if using_copy_on_write:
+            tm.assert_frame_equal(result_view, df_orig)
+        else:
+            tm.assert_frame_equal(result_view, expected)
+
+    def test_single_block_df_with_horizontal_axis(self):
+        # GH 47713
+        df = DataFrame(
+            {
+                "col1": [5, 0, np.nan, 10, np.nan],
+                "col2": [7, np.nan, np.nan, 5, 3],
+                "col3": [12, np.nan, 1, 2, 0],
+                "col4": [np.nan, 1, 1, np.nan, 18],
+            }
+        )
+        result = df.fillna(50, limit=1, axis=1)
+        expected = DataFrame(
+            [
+                [5.0, 7.0, 12.0, 50.0],
+                [0.0, 50.0, np.nan, 1.0],
+                [50.0, np.nan, 1.0, 1.0],
+                [10.0, 5.0, 2.0, 50.0],
+                [50.0, 3.0, 0.0, 18.0],
+            ],
+            columns=["col1", "col2", "col3", "col4"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_fillna_with_multi_index_frame(self):
+        # GH 47649
+        pdf = DataFrame(
+            {
+                ("x", "a"): [np.nan, 2.0, 3.0],
+                ("x", "b"): [1.0, 2.0, np.nan],
+                ("y", "c"): [1.0, 2.0, np.nan],
+            }
+        )
+        expected = DataFrame(
+            {
+                ("x", "a"): [-1.0, 2.0, 3.0],
+                ("x", "b"): [1.0, 2.0, -1.0],
+                ("y", "c"): [1.0, 2.0, np.nan],
+            }
+        )
+        tm.assert_frame_equal(pdf.fillna({"x": -1}), expected)
+        tm.assert_frame_equal(pdf.fillna({"x": -1, ("x", "b"): -2}), expected)
+
+        expected = DataFrame(
+            {
+                ("x", "a"): [-1.0, 2.0, 3.0],
+                ("x", "b"): [1.0, 2.0, -2.0],
+                ("y", "c"): [1.0, 2.0, np.nan],
+            }
+        )
+        tm.assert_frame_equal(pdf.fillna({("x", "b"): -2, "x": -1}), expected)
+
+
+def test_fillna_nonconsolidated_frame():
+    # https://github.com/pandas-dev/pandas/issues/36495
+    df = DataFrame(
+        [
+            [1, 1, 1, 1.0],
+            [2, 2, 2, 2.0],
+            [3, 3, 3, 3.0],
+        ],
+        columns=["i1", "i2", "i3", "f1"],
+    )
+    df_nonconsol = df.pivot(index="i1", columns="i2")
+    result = df_nonconsol.fillna(0)
+    assert result.isna().sum().sum() == 0
+
+
+def test_fillna_nones_inplace():
+    # GH 48480
+    df = DataFrame(
+        [[None, None], [None, None]],
+        columns=["A", "B"],
+    )
+    with tm.assert_produces_warning(False):
+        df.fillna(value={"A": 1, "B": 2}, inplace=True)
+
+    expected = DataFrame([[1, 2], [1, 2]], columns=["A", "B"])
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("func", ["pad", "backfill"])
+def test_pad_backfill_deprecated(func):
+    # GH#33396
+    df = DataFrame({"a": [1, 2, 3]})
+    with tm.assert_produces_warning(FutureWarning):
+        getattr(df, func)()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_filter.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_filter.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d5e6876bb08c2929e6a54c18b865e2720c1424d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_filter.py
@@ -0,0 +1,153 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestDataFrameFilter:
+    def test_filter(self, float_frame, float_string_frame):
+        # Items
+        filtered = float_frame.filter(["A", "B", "E"])
+        assert len(filtered.columns) == 2
+        assert "E" not in filtered
+
+        filtered = float_frame.filter(["A", "B", "E"], axis="columns")
+        assert len(filtered.columns) == 2
+        assert "E" not in filtered
+
+        # Other axis
+        idx = float_frame.index[0:4]
+        filtered = float_frame.filter(idx, axis="index")
+        expected = float_frame.reindex(index=idx)
+        tm.assert_frame_equal(filtered, expected)
+
+        # like
+        fcopy = float_frame.copy()
+        fcopy["AA"] = 1
+
+        filtered = fcopy.filter(like="A")
+        assert len(filtered.columns) == 2
+        assert "AA" in filtered
+
+        # like with ints in column names
+        df = DataFrame(0.0, index=[0, 1, 2], columns=[0, 1, "_A", "_B"])
+        filtered = df.filter(like="_")
+        assert len(filtered.columns) == 2
+
+        # regex with ints in column names
+        # from PR #10384
+        df = DataFrame(0.0, index=[0, 1, 2], columns=["A1", 1, "B", 2, "C"])
+        expected = DataFrame(
+            0.0, index=[0, 1, 2], columns=pd.Index([1, 2], dtype=object)
+        )
+        filtered = df.filter(regex="^[0-9]+$")
+        tm.assert_frame_equal(filtered, expected)
+
+        expected = DataFrame(0.0, index=[0, 1, 2], columns=[0, "0", 1, "1"])
+        # shouldn't remove anything
+        filtered = expected.filter(regex="^[0-9]+$")
+        tm.assert_frame_equal(filtered, expected)
+
+        # pass in None
+        with pytest.raises(TypeError, match="Must pass"):
+            float_frame.filter()
+        with pytest.raises(TypeError, match="Must pass"):
+            float_frame.filter(items=None)
+        with pytest.raises(TypeError, match="Must pass"):
+            float_frame.filter(axis=1)
+
+        # test mutually exclusive arguments
+        with pytest.raises(TypeError, match="mutually exclusive"):
+            float_frame.filter(items=["one", "three"], regex="e$", like="bbi")
+        with pytest.raises(TypeError, match="mutually exclusive"):
+            float_frame.filter(items=["one", "three"], regex="e$", axis=1)
+        with pytest.raises(TypeError, match="mutually exclusive"):
+            float_frame.filter(items=["one", "three"], regex="e$")
+        with pytest.raises(TypeError, match="mutually exclusive"):
+            float_frame.filter(items=["one", "three"], like="bbi", axis=0)
+        with pytest.raises(TypeError, match="mutually exclusive"):
+            float_frame.filter(items=["one", "three"], like="bbi")
+
+        # objects
+        filtered = float_string_frame.filter(like="foo")
+        assert "foo" in filtered
+
+        # unicode columns, won't ascii-encode
+        df = float_frame.rename(columns={"B": "\u2202"})
+        filtered = df.filter(like="C")
+        assert "C" in filtered
+
+    def test_filter_regex_search(self, float_frame):
+        fcopy = float_frame.copy()
+        fcopy["AA"] = 1
+
+        # regex
+        filtered = fcopy.filter(regex="[A]+")
+        assert len(filtered.columns) == 2
+        assert "AA" in filtered
+
+        # doesn't have to be at beginning
+        df = DataFrame(
+            {"aBBa": [1, 2], "BBaBB": [1, 2], "aCCa": [1, 2], "aCCaBB": [1, 2]}
+        )
+
+        result = df.filter(regex="BB")
+        exp = df[[x for x in df.columns if "BB" in x]]
+        tm.assert_frame_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "name,expected",
+        [
+            ("a", DataFrame({"a": [1, 2]})),
+            ("a", DataFrame({"a": [1, 2]})),
+            ("あ", DataFrame({"あ": [3, 4]})),
+        ],
+    )
+    def test_filter_unicode(self, name, expected):
+        # GH13101
+        df = DataFrame({"a": [1, 2], "あ": [3, 4]})
+
+        tm.assert_frame_equal(df.filter(like=name), expected)
+        tm.assert_frame_equal(df.filter(regex=name), expected)
+
+    @pytest.mark.parametrize("name", ["a", "a"])
+    def test_filter_bytestring(self, name):
+        # GH13101
+        df = DataFrame({b"a": [1, 2], b"b": [3, 4]})
+        expected = DataFrame({b"a": [1, 2]})
+
+        tm.assert_frame_equal(df.filter(like=name), expected)
+        tm.assert_frame_equal(df.filter(regex=name), expected)
+
+    def test_filter_corner(self):
+        empty = DataFrame()
+
+        result = empty.filter([])
+        tm.assert_frame_equal(result, empty)
+
+        result = empty.filter(like="foo")
+        tm.assert_frame_equal(result, empty)
+
+    def test_filter_regex_non_string(self):
+        # GH#5798 trying to filter on non-string columns should drop,
+        #  not raise
+        df = DataFrame(np.random.default_rng(2).random((3, 2)), columns=["STRING", 123])
+        result = df.filter(regex="STRING")
+        expected = df[["STRING"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_filter_keep_order(self):
+        # GH#54980
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        result = df.filter(items=["B", "A"])
+        expected = df[["B", "A"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_filter_different_dtype(self):
+        # GH#54980
+        df = DataFrame({1: [1, 2, 3], 2: [4, 5, 6]})
+        result = df.filter(items=["B", "A"])
+        expected = df[[]]
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_first_and_last.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_first_and_last.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e85edc7ed0ea6db3ca87841b223e3581fb60059
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_first_and_last.py
@@ -0,0 +1,124 @@
+"""
+Note: includes tests for `last`
+"""
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    bdate_range,
+)
+import pandas._testing as tm
+
+deprecated_msg = "first is deprecated"
+last_deprecated_msg = "last is deprecated"
+
+
+class TestFirst:
+    def test_first_subset(self, frame_or_series):
+        ts = tm.makeTimeDataFrame(freq="12h")
+        ts = tm.get_obj(ts, frame_or_series)
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = ts.first("10d")
+            assert len(result) == 20
+
+        ts = tm.makeTimeDataFrame(freq="D")
+        ts = tm.get_obj(ts, frame_or_series)
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = ts.first("10d")
+            assert len(result) == 10
+
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = ts.first("3M")
+            expected = ts[:"3/31/2000"]
+            tm.assert_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = ts.first("21D")
+            expected = ts[:21]
+            tm.assert_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = ts[:0].first("3M")
+            tm.assert_equal(result, ts[:0])
+
+    def test_first_last_raises(self, frame_or_series):
+        # GH#20725
+        obj = DataFrame([[1, 2, 3], [4, 5, 6]])
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = "'first' only supports a DatetimeIndex index"
+        with tm.assert_produces_warning(
+            FutureWarning, match=deprecated_msg
+        ), pytest.raises(
+            TypeError, match=msg
+        ):  # index is not a DatetimeIndex
+            obj.first("1D")
+
+        msg = "'last' only supports a DatetimeIndex index"
+        with tm.assert_produces_warning(
+            FutureWarning, match=last_deprecated_msg
+        ), pytest.raises(
+            TypeError, match=msg
+        ):  # index is not a DatetimeIndex
+            obj.last("1D")
+
+    def test_last_subset(self, frame_or_series):
+        ts = tm.makeTimeDataFrame(freq="12h")
+        ts = tm.get_obj(ts, frame_or_series)
+        with tm.assert_produces_warning(FutureWarning, match=last_deprecated_msg):
+            result = ts.last("10d")
+        assert len(result) == 20
+
+        ts = tm.makeTimeDataFrame(nper=30, freq="D")
+        ts = tm.get_obj(ts, frame_or_series)
+        with tm.assert_produces_warning(FutureWarning, match=last_deprecated_msg):
+            result = ts.last("10d")
+        assert len(result) == 10
+
+        with tm.assert_produces_warning(FutureWarning, match=last_deprecated_msg):
+            result = ts.last("21D")
+        expected = ts["2000-01-10":]
+        tm.assert_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=last_deprecated_msg):
+            result = ts.last("21D")
+        expected = ts[-21:]
+        tm.assert_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=last_deprecated_msg):
+            result = ts[:0].last("3M")
+        tm.assert_equal(result, ts[:0])
+
+    @pytest.mark.parametrize("start, periods", [("2010-03-31", 1), ("2010-03-30", 2)])
+    def test_first_with_first_day_last_of_month(self, frame_or_series, start, periods):
+        # GH#29623
+        x = frame_or_series([1] * 100, index=bdate_range(start, periods=100))
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = x.first("1M")
+        expected = frame_or_series(
+            [1] * periods, index=bdate_range(start, periods=periods)
+        )
+        tm.assert_equal(result, expected)
+
+    def test_first_with_first_day_end_of_frq_n_greater_one(self, frame_or_series):
+        # GH#29623
+        x = frame_or_series([1] * 100, index=bdate_range("2010-03-31", periods=100))
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = x.first("2M")
+        expected = frame_or_series(
+            [1] * 23, index=bdate_range("2010-03-31", "2010-04-30")
+        )
+        tm.assert_equal(result, expected)
+
+    def test_empty_not_input(self):
+        # GH#51032
+        df = DataFrame(index=pd.DatetimeIndex([]))
+        with tm.assert_produces_warning(FutureWarning, match=last_deprecated_msg):
+            result = df.last(offset=1)
+
+        with tm.assert_produces_warning(FutureWarning, match=deprecated_msg):
+            result = df.first(offset=1)
+
+        tm.assert_frame_equal(df, result)
+        assert df is not result
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_first_valid_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_first_valid_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..a448768f4173d704ac55bf60c532effa30b8d970
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_first_valid_index.py
@@ -0,0 +1,74 @@
+"""
+Includes test for last_valid_index.
+"""
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestFirstValidIndex:
+    def test_first_valid_index_single_nan(self, frame_or_series):
+        # GH#9752 Series/DataFrame should both return None, not raise
+        obj = frame_or_series([np.nan])
+
+        assert obj.first_valid_index() is None
+        assert obj.iloc[:0].first_valid_index() is None
+
+    @pytest.mark.parametrize(
+        "empty", [DataFrame(), Series(dtype=object), Series([], index=[], dtype=object)]
+    )
+    def test_first_valid_index_empty(self, empty):
+        # GH#12800
+        assert empty.last_valid_index() is None
+        assert empty.first_valid_index() is None
+
+    @pytest.mark.parametrize(
+        "data,idx,expected_first,expected_last",
+        [
+            ({"A": [1, 2, 3]}, [1, 1, 2], 1, 2),
+            ({"A": [1, 2, 3]}, [1, 2, 2], 1, 2),
+            ({"A": [1, 2, 3, 4]}, ["d", "d", "d", "d"], "d", "d"),
+            ({"A": [1, np.nan, 3]}, [1, 1, 2], 1, 2),
+            ({"A": [np.nan, np.nan, 3]}, [1, 1, 2], 2, 2),
+            ({"A": [1, np.nan, 3]}, [1, 2, 2], 1, 2),
+        ],
+    )
+    def test_first_last_valid_frame(self, data, idx, expected_first, expected_last):
+        # GH#21441
+        df = DataFrame(data, index=idx)
+        assert expected_first == df.first_valid_index()
+        assert expected_last == df.last_valid_index()
+
+    @pytest.mark.parametrize("index_func", [tm.makeStringIndex, tm.makeDateIndex])
+    def test_first_last_valid(self, index_func):
+        N = 30
+        index = index_func(N)
+        mat = np.random.default_rng(2).standard_normal(N)
+        mat[:5] = np.nan
+        mat[-5:] = np.nan
+
+        frame = DataFrame({"foo": mat}, index=index)
+        assert frame.first_valid_index() == frame.index[5]
+        assert frame.last_valid_index() == frame.index[-6]
+
+        ser = frame["foo"]
+        assert ser.first_valid_index() == frame.index[5]
+        assert ser.last_valid_index() == frame.index[-6]
+
+    @pytest.mark.parametrize("index_func", [tm.makeStringIndex, tm.makeDateIndex])
+    def test_first_last_valid_all_nan(self, index_func):
+        # GH#17400: no valid entries
+        index = index_func(30)
+        frame = DataFrame(np.nan, columns=["foo"], index=index)
+
+        assert frame.last_valid_index() is None
+        assert frame.first_valid_index() is None
+
+        ser = frame["foo"]
+        assert ser.first_valid_index() is None
+        assert ser.last_valid_index() is None
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_get_numeric_data.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_get_numeric_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec1c768603a598efd244025ded97e5fc1780cd4a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_get_numeric_data.py
@@ -0,0 +1,102 @@
+import numpy as np
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.arrays import IntervalArray
+
+
+class TestGetNumericData:
+    def test_get_numeric_data_preserve_dtype(self):
+        # get the numeric data
+        obj = DataFrame({"A": [1, "2", 3.0]})
+        result = obj._get_numeric_data()
+        expected = DataFrame(dtype=object, index=pd.RangeIndex(3), columns=[])
+        tm.assert_frame_equal(result, expected)
+
+    def test_get_numeric_data(self):
+        datetime64name = np.dtype("M8[s]").name
+        objectname = np.dtype(np.object_).name
+
+        df = DataFrame(
+            {"a": 1.0, "b": 2, "c": "foo", "f": Timestamp("20010102")},
+            index=np.arange(10),
+        )
+        result = df.dtypes
+        expected = Series(
+            [
+                np.dtype("float64"),
+                np.dtype("int64"),
+                np.dtype(objectname),
+                np.dtype(datetime64name),
+            ],
+            index=["a", "b", "c", "f"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        df = DataFrame(
+            {
+                "a": 1.0,
+                "b": 2,
+                "c": "foo",
+                "d": np.array([1.0] * 10, dtype="float32"),
+                "e": np.array([1] * 10, dtype="int32"),
+                "f": np.array([1] * 10, dtype="int16"),
+                "g": Timestamp("20010102"),
+            },
+            index=np.arange(10),
+        )
+
+        result = df._get_numeric_data()
+        expected = df.loc[:, ["a", "b", "d", "e", "f"]]
+        tm.assert_frame_equal(result, expected)
+
+        only_obj = df.loc[:, ["c", "g"]]
+        result = only_obj._get_numeric_data()
+        expected = df.loc[:, []]
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame.from_dict({"a": [1, 2], "b": ["foo", "bar"], "c": [np.pi, np.e]})
+        result = df._get_numeric_data()
+        expected = DataFrame.from_dict({"a": [1, 2], "c": [np.pi, np.e]})
+        tm.assert_frame_equal(result, expected)
+
+        df = result.copy()
+        result = df._get_numeric_data()
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+    def test_get_numeric_data_mixed_dtype(self):
+        # numeric and object columns
+
+        df = DataFrame(
+            {
+                "a": [1, 2, 3],
+                "b": [True, False, True],
+                "c": ["foo", "bar", "baz"],
+                "d": [None, None, None],
+                "e": [3.14, 0.577, 2.773],
+            }
+        )
+        result = df._get_numeric_data()
+        tm.assert_index_equal(result.columns, Index(["a", "b", "e"]))
+
+    def test_get_numeric_data_extension_dtype(self):
+        # GH#22290
+        df = DataFrame(
+            {
+                "A": pd.array([-10, np.nan, 0, 10, 20, 30], dtype="Int64"),
+                "B": Categorical(list("abcabc")),
+                "C": pd.array([0, 1, 2, 3, np.nan, 5], dtype="UInt8"),
+                "D": IntervalArray.from_breaks(range(7)),
+            }
+        )
+        result = df._get_numeric_data()
+        expected = df.loc[:, ["A", "C"]]
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_head_tail.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_head_tail.py
new file mode 100644
index 0000000000000000000000000000000000000000..9363c4d79983f0530bc17666aec7ec8609fb93e4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_head_tail.py
@@ -0,0 +1,57 @@
+import numpy as np
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+def test_head_tail_generic(index, frame_or_series):
+    # GH#5370
+
+    ndim = 2 if frame_or_series is DataFrame else 1
+    shape = (len(index),) * ndim
+    vals = np.random.default_rng(2).standard_normal(shape)
+    obj = frame_or_series(vals, index=index)
+
+    tm.assert_equal(obj.head(), obj.iloc[:5])
+    tm.assert_equal(obj.tail(), obj.iloc[-5:])
+
+    # 0-len
+    tm.assert_equal(obj.head(0), obj.iloc[0:0])
+    tm.assert_equal(obj.tail(0), obj.iloc[0:0])
+
+    # bounded
+    tm.assert_equal(obj.head(len(obj) + 1), obj)
+    tm.assert_equal(obj.tail(len(obj) + 1), obj)
+
+    # neg index
+    tm.assert_equal(obj.head(-3), obj.head(len(index) - 3))
+    tm.assert_equal(obj.tail(-3), obj.tail(len(index) - 3))
+
+
+def test_head_tail(float_frame):
+    tm.assert_frame_equal(float_frame.head(), float_frame[:5])
+    tm.assert_frame_equal(float_frame.tail(), float_frame[-5:])
+
+    tm.assert_frame_equal(float_frame.head(0), float_frame[0:0])
+    tm.assert_frame_equal(float_frame.tail(0), float_frame[0:0])
+
+    tm.assert_frame_equal(float_frame.head(-1), float_frame[:-1])
+    tm.assert_frame_equal(float_frame.tail(-1), float_frame[1:])
+    tm.assert_frame_equal(float_frame.head(1), float_frame[:1])
+    tm.assert_frame_equal(float_frame.tail(1), float_frame[-1:])
+    # with a float index
+    df = float_frame.copy()
+    df.index = np.arange(len(float_frame)) + 0.1
+    tm.assert_frame_equal(df.head(), df.iloc[:5])
+    tm.assert_frame_equal(df.tail(), df.iloc[-5:])
+    tm.assert_frame_equal(df.head(0), df[0:0])
+    tm.assert_frame_equal(df.tail(0), df[0:0])
+    tm.assert_frame_equal(df.head(-1), df.iloc[:-1])
+    tm.assert_frame_equal(df.tail(-1), df.iloc[1:])
+
+
+def test_head_tail_empty():
+    # test empty dataframe
+    empty_df = DataFrame()
+    tm.assert_frame_equal(empty_df.tail(), empty_df)
+    tm.assert_frame_equal(empty_df.head(), empty_df)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_infer_objects.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_infer_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..a824a615b5c297c13afeedeba600c1a0ba986695
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_infer_objects.py
@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestInferObjects:
+    def test_infer_objects(self):
+        # GH#11221
+        df = DataFrame(
+            {
+                "a": ["a", 1, 2, 3],
+                "b": ["b", 2.0, 3.0, 4.1],
+                "c": [
+                    "c",
+                    datetime(2016, 1, 1),
+                    datetime(2016, 1, 2),
+                    datetime(2016, 1, 3),
+                ],
+                "d": [1, 2, 3, "d"],
+            },
+            columns=["a", "b", "c", "d"],
+        )
+        df = df.iloc[1:].infer_objects()
+
+        assert df["a"].dtype == "int64"
+        assert df["b"].dtype == "float64"
+        assert df["c"].dtype == "M8[ns]"
+        assert df["d"].dtype == "object"
+
+        expected = DataFrame(
+            {
+                "a": [1, 2, 3],
+                "b": [2.0, 3.0, 4.1],
+                "c": [datetime(2016, 1, 1), datetime(2016, 1, 2), datetime(2016, 1, 3)],
+                "d": [2, 3, "d"],
+            },
+            columns=["a", "b", "c", "d"],
+        )
+        # reconstruct frame to verify inference is same
+        result = df.reset_index(drop=True)
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_interpolate.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_interpolate.py
new file mode 100644
index 0000000000000000000000000000000000000000..67aa07dd83764d0061b444b1d338c6db5327e783
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_interpolate.py
@@ -0,0 +1,505 @@
+import numpy as np
+import pytest
+
+from pandas.errors import ChainedAssignmentError
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    NaT,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameInterpolate:
+    def test_interpolate_complex(self):
+        # GH#53635
+        ser = Series([complex("1+1j"), float("nan"), complex("2+2j")])
+        assert ser.dtype.kind == "c"
+
+        res = ser.interpolate()
+        expected = Series([ser[0], ser[0] * 1.5, ser[2]])
+        tm.assert_series_equal(res, expected)
+
+        df = ser.to_frame()
+        res = df.interpolate()
+        expected = expected.to_frame()
+        tm.assert_frame_equal(res, expected)
+
+    def test_interpolate_datetimelike_values(self, frame_or_series):
+        # GH#11312, GH#51005
+        orig = Series(date_range("2012-01-01", periods=5))
+        ser = orig.copy()
+        ser[2] = NaT
+
+        res = frame_or_series(ser).interpolate()
+        expected = frame_or_series(orig)
+        tm.assert_equal(res, expected)
+
+        # datetime64tz cast
+        ser_tz = ser.dt.tz_localize("US/Pacific")
+        res_tz = frame_or_series(ser_tz).interpolate()
+        expected_tz = frame_or_series(orig.dt.tz_localize("US/Pacific"))
+        tm.assert_equal(res_tz, expected_tz)
+
+        # timedelta64 cast
+        ser_td = ser - ser[0]
+        res_td = frame_or_series(ser_td).interpolate()
+        expected_td = frame_or_series(orig - orig[0])
+        tm.assert_equal(res_td, expected_td)
+
+    def test_interpolate_inplace(self, frame_or_series, using_array_manager, request):
+        # GH#44749
+        if using_array_manager and frame_or_series is DataFrame:
+            mark = pytest.mark.xfail(reason=".values-based in-place check is invalid")
+            request.node.add_marker(mark)
+
+        obj = frame_or_series([1, np.nan, 2])
+        orig = obj.values
+
+        obj.interpolate(inplace=True)
+        expected = frame_or_series([1, 1.5, 2])
+        tm.assert_equal(obj, expected)
+
+        # check we operated *actually* inplace
+        assert np.shares_memory(orig, obj.values)
+        assert orig.squeeze()[1] == 1.5
+
+    def test_interp_basic(self, using_copy_on_write):
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 4],
+                "B": [1, 4, 9, np.nan],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+        expected = DataFrame(
+            {
+                "A": [1.0, 2.0, 3.0, 4.0],
+                "B": [1.0, 4.0, 9.0, 9.0],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+        msg = "DataFrame.interpolate with object dtype"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.interpolate()
+        tm.assert_frame_equal(result, expected)
+
+        # check we didn't operate inplace GH#45791
+        cvalues = df["C"]._values
+        dvalues = df["D"].values
+        if using_copy_on_write:
+            assert np.shares_memory(cvalues, result["C"]._values)
+            assert np.shares_memory(dvalues, result["D"]._values)
+        else:
+            assert not np.shares_memory(cvalues, result["C"]._values)
+            assert not np.shares_memory(dvalues, result["D"]._values)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = df.interpolate(inplace=True)
+        assert res is None
+        tm.assert_frame_equal(df, expected)
+
+        # check we DID operate inplace
+        assert np.shares_memory(df["C"]._values, cvalues)
+        assert np.shares_memory(df["D"]._values, dvalues)
+
+    def test_interp_basic_with_non_range_index(self):
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 4],
+                "B": [1, 4, 9, np.nan],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+
+        msg = "DataFrame.interpolate with object dtype"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.set_index("C").interpolate()
+        expected = df.set_index("C")
+        expected.loc[3, "A"] = 3
+        expected.loc[5, "B"] = 9
+        tm.assert_frame_equal(result, expected)
+
+    def test_interp_empty(self):
+        # https://github.com/pandas-dev/pandas/issues/35598
+        df = DataFrame()
+        result = df.interpolate()
+        assert result is not df
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+    def test_interp_bad_method(self):
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 4],
+                "B": [1, 4, 9, np.nan],
+                "C": [1, 2, 3, 5],
+            }
+        )
+        msg = (
+            r"method must be one of \['linear', 'time', 'index', 'values', "
+            r"'nearest', 'zero', 'slinear', 'quadratic', 'cubic', "
+            r"'barycentric', 'krogh', 'spline', 'polynomial', "
+            r"'from_derivatives', 'piecewise_polynomial', 'pchip', 'akima', "
+            r"'cubicspline'\]. Got 'not_a_method' instead."
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.interpolate(method="not_a_method")
+
+    def test_interp_combo(self):
+        df = DataFrame(
+            {
+                "A": [1.0, 2.0, np.nan, 4.0],
+                "B": [1, 4, 9, np.nan],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+
+        result = df["A"].interpolate()
+        expected = Series([1.0, 2.0, 3.0, 4.0], name="A")
+        tm.assert_series_equal(result, expected)
+
+        msg = "The 'downcast' keyword in Series.interpolate is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df["A"].interpolate(downcast="infer")
+        expected = Series([1, 2, 3, 4], name="A")
+        tm.assert_series_equal(result, expected)
+
+    def test_inerpolate_invalid_downcast(self):
+        # GH#53103
+        df = DataFrame(
+            {
+                "A": [1.0, 2.0, np.nan, 4.0],
+                "B": [1, 4, 9, np.nan],
+                "C": [1, 2, 3, 5],
+                "D": list("abcd"),
+            }
+        )
+
+        msg = "downcast must be either None or 'infer'"
+        msg2 = "The 'downcast' keyword in DataFrame.interpolate is deprecated"
+        msg3 = "The 'downcast' keyword in Series.interpolate is deprecated"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                df.interpolate(downcast="int64")
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg3):
+                df["A"].interpolate(downcast="int64")
+
+    def test_interp_nan_idx(self):
+        df = DataFrame({"A": [1, 2, np.nan, 4], "B": [np.nan, 2, 3, 4]})
+        df = df.set_index("A")
+        msg = (
+            "Interpolation with NaNs in the index has not been implemented. "
+            "Try filling those NaNs before interpolating."
+        )
+        with pytest.raises(NotImplementedError, match=msg):
+            df.interpolate(method="values")
+
+    def test_interp_various(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 4, 5, np.nan, 7], "C": [1, 2, 3, 5, 8, 13, 21]}
+        )
+        df = df.set_index("C")
+        expected = df.copy()
+        result = df.interpolate(method="polynomial", order=1)
+
+        expected.loc[3, "A"] = 2.66666667
+        expected.loc[13, "A"] = 5.76923076
+        tm.assert_frame_equal(result, expected)
+
+        result = df.interpolate(method="cubic")
+        # GH #15662.
+        expected.loc[3, "A"] = 2.81547781
+        expected.loc[13, "A"] = 5.52964175
+        tm.assert_frame_equal(result, expected)
+
+        result = df.interpolate(method="nearest")
+        expected.loc[3, "A"] = 2
+        expected.loc[13, "A"] = 5
+        tm.assert_frame_equal(result, expected, check_dtype=False)
+
+        result = df.interpolate(method="quadratic")
+        expected.loc[3, "A"] = 2.82150771
+        expected.loc[13, "A"] = 6.12648668
+        tm.assert_frame_equal(result, expected)
+
+        result = df.interpolate(method="slinear")
+        expected.loc[3, "A"] = 2.66666667
+        expected.loc[13, "A"] = 5.76923077
+        tm.assert_frame_equal(result, expected)
+
+        result = df.interpolate(method="zero")
+        expected.loc[3, "A"] = 2.0
+        expected.loc[13, "A"] = 5
+        tm.assert_frame_equal(result, expected, check_dtype=False)
+
+    def test_interp_alt_scipy(self):
+        pytest.importorskip("scipy")
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 4, 5, np.nan, 7], "C": [1, 2, 3, 5, 8, 13, 21]}
+        )
+        result = df.interpolate(method="barycentric")
+        expected = df.copy()
+        expected.loc[2, "A"] = 3
+        expected.loc[5, "A"] = 6
+        tm.assert_frame_equal(result, expected)
+
+        msg = "The 'downcast' keyword in DataFrame.interpolate is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.interpolate(method="barycentric", downcast="infer")
+        tm.assert_frame_equal(result, expected.astype(np.int64))
+
+        result = df.interpolate(method="krogh")
+        expectedk = df.copy()
+        expectedk["A"] = expected["A"]
+        tm.assert_frame_equal(result, expectedk)
+
+        result = df.interpolate(method="pchip")
+        expected.loc[2, "A"] = 3
+        expected.loc[5, "A"] = 6.0
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_interp_rowwise(self):
+        df = DataFrame(
+            {
+                0: [1, 2, np.nan, 4],
+                1: [2, 3, 4, np.nan],
+                2: [np.nan, 4, 5, 6],
+                3: [4, np.nan, 6, 7],
+                4: [1, 2, 3, 4],
+            }
+        )
+        result = df.interpolate(axis=1)
+        expected = df.copy()
+        expected.loc[3, 1] = 5
+        expected.loc[0, 2] = 3
+        expected.loc[1, 3] = 3
+        expected[4] = expected[4].astype(np.float64)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.interpolate(axis=1, method="values")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.interpolate(axis=0)
+        expected = df.interpolate()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "axis_name, axis_number",
+        [
+            pytest.param("rows", 0, id="rows_0"),
+            pytest.param("index", 0, id="index_0"),
+            pytest.param("columns", 1, id="columns_1"),
+        ],
+    )
+    def test_interp_axis_names(self, axis_name, axis_number):
+        # GH 29132: test axis names
+        data = {0: [0, np.nan, 6], 1: [1, np.nan, 7], 2: [2, 5, 8]}
+
+        df = DataFrame(data, dtype=np.float64)
+        result = df.interpolate(axis=axis_name, method="linear")
+        expected = df.interpolate(axis=axis_number, method="linear")
+        tm.assert_frame_equal(result, expected)
+
+    def test_rowwise_alt(self):
+        df = DataFrame(
+            {
+                0: [0, 0.5, 1.0, np.nan, 4, 8, np.nan, np.nan, 64],
+                1: [1, 2, 3, 4, 3, 2, 1, 0, -1],
+            }
+        )
+        df.interpolate(axis=0)
+        # TODO: assert something?
+
+    @pytest.mark.parametrize(
+        "check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
+    )
+    def test_interp_leading_nans(self, check_scipy):
+        df = DataFrame(
+            {"A": [np.nan, np.nan, 0.5, 0.25, 0], "B": [np.nan, -3, -3.5, np.nan, -4]}
+        )
+        result = df.interpolate()
+        expected = df.copy()
+        expected.loc[3, "B"] = -3.75
+        tm.assert_frame_equal(result, expected)
+
+        if check_scipy:
+            result = df.interpolate(method="polynomial", order=1)
+            tm.assert_frame_equal(result, expected)
+
+    def test_interp_raise_on_only_mixed(self, axis):
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 4],
+                "B": ["a", "b", "c", "d"],
+                "C": [np.nan, 2, 5, 7],
+                "D": [np.nan, np.nan, 9, 9],
+                "E": [1, 2, 3, 4],
+            }
+        )
+        msg = (
+            "Cannot interpolate with all object-dtype columns "
+            "in the DataFrame. Try setting at least one "
+            "column to a numeric dtype."
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.astype("object").interpolate(axis=axis)
+
+    def test_interp_raise_on_all_object_dtype(self):
+        # GH 22985
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, dtype="object")
+        msg = (
+            "Cannot interpolate with all object-dtype columns "
+            "in the DataFrame. Try setting at least one "
+            "column to a numeric dtype."
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.interpolate()
+
+    def test_interp_inplace(self, using_copy_on_write):
+        df = DataFrame({"a": [1.0, 2.0, np.nan, 4.0]})
+        expected = DataFrame({"a": [1.0, 2.0, 3.0, 4.0]})
+        expected_cow = df.copy()
+        result = df.copy()
+
+        if using_copy_on_write:
+            with tm.raises_chained_assignment_error():
+                return_value = result["a"].interpolate(inplace=True)
+            assert return_value is None
+            tm.assert_frame_equal(result, expected_cow)
+        else:
+            return_value = result["a"].interpolate(inplace=True)
+            assert return_value is None
+            tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        msg = "The 'downcast' keyword in Series.interpolate is deprecated"
+
+        if using_copy_on_write:
+            with tm.assert_produces_warning(
+                (FutureWarning, ChainedAssignmentError), match=msg
+            ):
+                return_value = result["a"].interpolate(inplace=True, downcast="infer")
+            assert return_value is None
+            tm.assert_frame_equal(result, expected_cow)
+        else:
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                return_value = result["a"].interpolate(inplace=True, downcast="infer")
+            assert return_value is None
+            tm.assert_frame_equal(result, expected.astype("int64"))
+
+    def test_interp_inplace_row(self):
+        # GH 10395
+        result = DataFrame(
+            {"a": [1.0, 2.0, 3.0, 4.0], "b": [np.nan, 2.0, 3.0, 4.0], "c": [3, 2, 2, 2]}
+        )
+        expected = result.interpolate(method="linear", axis=1, inplace=False)
+        return_value = result.interpolate(method="linear", axis=1, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(result, expected)
+
+    def test_interp_ignore_all_good(self):
+        # GH
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 4],
+                "B": [1, 2, 3, 4],
+                "C": [1.0, 2.0, np.nan, 4.0],
+                "D": [1.0, 2.0, 3.0, 4.0],
+            }
+        )
+        expected = DataFrame(
+            {
+                "A": np.array([1, 2, 3, 4], dtype="float64"),
+                "B": np.array([1, 2, 3, 4], dtype="int64"),
+                "C": np.array([1.0, 2.0, 3, 4.0], dtype="float64"),
+                "D": np.array([1.0, 2.0, 3.0, 4.0], dtype="float64"),
+            }
+        )
+
+        msg = "The 'downcast' keyword in DataFrame.interpolate is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.interpolate(downcast=None)
+        tm.assert_frame_equal(result, expected)
+
+        # all good
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df[["B", "D"]].interpolate(downcast=None)
+        tm.assert_frame_equal(result, df[["B", "D"]])
+
+    def test_interp_time_inplace_axis(self):
+        # GH 9687
+        periods = 5
+        idx = date_range(start="2014-01-01", periods=periods)
+        data = np.random.default_rng(2).random((periods, periods))
+        data[data < 0.5] = np.nan
+        expected = DataFrame(index=idx, columns=idx, data=data)
+
+        result = expected.interpolate(axis=0, method="time")
+        return_value = expected.interpolate(axis=0, method="time", inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("axis_name, axis_number", [("index", 0), ("columns", 1)])
+    def test_interp_string_axis(self, axis_name, axis_number):
+        # https://github.com/pandas-dev/pandas/issues/25190
+        x = np.linspace(0, 100, 1000)
+        y = np.sin(x)
+        df = DataFrame(
+            data=np.tile(y, (10, 1)), index=np.arange(10), columns=x
+        ).reindex(columns=x * 1.005)
+        result = df.interpolate(method="linear", axis=axis_name)
+        expected = df.interpolate(method="linear", axis=axis_number)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("multiblock", [True, False])
+    @pytest.mark.parametrize("method", ["ffill", "bfill", "pad"])
+    def test_interp_fillna_methods(
+        self, request, axis, multiblock, method, using_array_manager
+    ):
+        # GH 12918
+        if using_array_manager and axis in (1, "columns"):
+            # TODO(ArrayManager) support axis=1
+            td.mark_array_manager_not_yet_implemented(request)
+
+        df = DataFrame(
+            {
+                "A": [1.0, 2.0, 3.0, 4.0, np.nan, 5.0],
+                "B": [2.0, 4.0, 6.0, np.nan, 8.0, 10.0],
+                "C": [3.0, 6.0, 9.0, np.nan, np.nan, 30.0],
+            }
+        )
+        if multiblock:
+            df["D"] = np.nan
+            df["E"] = 1.0
+
+        method2 = method if method != "pad" else "ffill"
+        expected = getattr(df, method2)(axis=axis)
+        msg = f"DataFrame.interpolate with method={method} is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.interpolate(method=method, axis=axis)
+        tm.assert_frame_equal(result, expected)
+
+    def test_interpolate_empty_df(self):
+        # GH#53199
+        df = DataFrame()
+        expected = df.copy()
+        result = df.interpolate(inplace=True)
+        assert result is None
+        tm.assert_frame_equal(df, expected)
+
+    def test_interpolate_ea_raise(self):
+        # GH#55347
+        df = DataFrame({"a": [1, None, 2]}, dtype="Int64")
+        with pytest.raises(NotImplementedError, match="does not implement"):
+            df.interpolate()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_is_homogeneous_dtype.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_is_homogeneous_dtype.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5f285d31301b24f95d12e742c8e9e30b7fefbf4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_is_homogeneous_dtype.py
@@ -0,0 +1,57 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    Categorical,
+    DataFrame,
+)
+
+# _is_homogeneous_type always returns True for ArrayManager
+pytestmark = td.skip_array_manager_invalid_test
+
+
+@pytest.mark.parametrize(
+    "data, expected",
+    [
+        # empty
+        (DataFrame(), True),
+        # multi-same
+        (DataFrame({"A": [1, 2], "B": [1, 2]}), True),
+        # multi-object
+        (
+            DataFrame(
+                {
+                    "A": np.array([1, 2], dtype=object),
+                    "B": np.array(["a", "b"], dtype=object),
+                }
+            ),
+            True,
+        ),
+        # multi-extension
+        (
+            DataFrame({"A": Categorical(["a", "b"]), "B": Categorical(["a", "b"])}),
+            True,
+        ),
+        # differ types
+        (DataFrame({"A": [1, 2], "B": [1.0, 2.0]}), False),
+        # differ sizes
+        (
+            DataFrame(
+                {
+                    "A": np.array([1, 2], dtype=np.int32),
+                    "B": np.array([1, 2], dtype=np.int64),
+                }
+            ),
+            False,
+        ),
+        # multi-extension differ
+        (
+            DataFrame({"A": Categorical(["a", "b"]), "B": Categorical(["b", "c"])}),
+            False,
+        ),
+    ],
+)
+def test_is_homogeneous_type(data, expected):
+    assert data._is_homogeneous_type is expected
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_isetitem.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_isetitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..69f394afb65191fe4cc52519fbc52959d2e1dd76
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_isetitem.py
@@ -0,0 +1,50 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameSetItem:
+    def test_isetitem_ea_df(self):
+        # GH#49922
+        df = DataFrame([[1, 2, 3], [4, 5, 6]])
+        rhs = DataFrame([[11, 12], [13, 14]], dtype="Int64")
+
+        df.isetitem([0, 1], rhs)
+        expected = DataFrame(
+            {
+                0: Series([11, 13], dtype="Int64"),
+                1: Series([12, 14], dtype="Int64"),
+                2: [3, 6],
+            }
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_isetitem_ea_df_scalar_indexer(self):
+        # GH#49922
+        df = DataFrame([[1, 2, 3], [4, 5, 6]])
+        rhs = DataFrame([[11], [13]], dtype="Int64")
+
+        df.isetitem(2, rhs)
+        expected = DataFrame(
+            {
+                0: [1, 4],
+                1: [2, 5],
+                2: Series([11, 13], dtype="Int64"),
+            }
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_isetitem_dimension_mismatch(self):
+        # GH#51701
+        df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]})
+        value = df.copy()
+        with pytest.raises(ValueError, match="Got 2 positions but value has 3 columns"):
+            df.isetitem([1, 2], value)
+
+        value = df.copy()
+        with pytest.raises(ValueError, match="Got 2 positions but value has 1 columns"):
+            df.isetitem([1, 2], value[["a"]])
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_isin.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_isin.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4511aad27a93bd2d9411ac5cdb427196dbf9dda
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_isin.py
@@ -0,0 +1,227 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameIsIn:
+    def test_isin(self):
+        # GH#4211
+        df = DataFrame(
+            {
+                "vals": [1, 2, 3, 4],
+                "ids": ["a", "b", "f", "n"],
+                "ids2": ["a", "n", "c", "n"],
+            },
+            index=["foo", "bar", "baz", "qux"],
+        )
+        other = ["a", "b", "c"]
+
+        result = df.isin(other)
+        expected = DataFrame([df.loc[s].isin(other) for s in df.index])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
+    def test_isin_empty(self, empty):
+        # GH#16991
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        expected = DataFrame(False, df.index, df.columns)
+
+        result = df.isin(empty)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_dict(self):
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        d = {"A": ["a"]}
+
+        expected = DataFrame(False, df.index, df.columns)
+        expected.loc[0, "A"] = True
+
+        result = df.isin(d)
+        tm.assert_frame_equal(result, expected)
+
+        # non unique columns
+        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
+        df.columns = ["A", "A"]
+        expected = DataFrame(False, df.index, df.columns)
+        expected.loc[0, "A"] = True
+        result = df.isin(d)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_with_string_scalar(self):
+        # GH#4763
+        df = DataFrame(
+            {
+                "vals": [1, 2, 3, 4],
+                "ids": ["a", "b", "f", "n"],
+                "ids2": ["a", "n", "c", "n"],
+            },
+            index=["foo", "bar", "baz", "qux"],
+        )
+        msg = (
+            r"only list-like or dict-like objects are allowed "
+            r"to be passed to DataFrame.isin\(\), you passed a 'str'"
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.isin("a")
+
+        with pytest.raises(TypeError, match=msg):
+            df.isin("aaa")
+
+    def test_isin_df(self):
+        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
+        df2 = DataFrame({"A": [0, 2, 12, 4], "B": [2, np.nan, 4, 5]})
+        expected = DataFrame(False, df1.index, df1.columns)
+        result = df1.isin(df2)
+        expected.loc[[1, 3], "A"] = True
+        expected.loc[[0, 2], "B"] = True
+        tm.assert_frame_equal(result, expected)
+
+        # partial overlapping columns
+        df2.columns = ["A", "C"]
+        result = df1.isin(df2)
+        expected["B"] = False
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_tuples(self):
+        # GH#16394
+        df = DataFrame({"A": [1, 2, 3], "B": ["a", "b", "f"]})
+        df["C"] = list(zip(df["A"], df["B"]))
+        result = df["C"].isin([(1, "a")])
+        tm.assert_series_equal(result, Series([True, False, False], name="C"))
+
+    def test_isin_df_dupe_values(self):
+        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
+        # just cols duped
+        df2 = DataFrame([[0, 2], [12, 4], [2, np.nan], [4, 5]], columns=["B", "B"])
+        msg = r"cannot compute isin with a duplicate axis\."
+        with pytest.raises(ValueError, match=msg):
+            df1.isin(df2)
+
+        # just index duped
+        df2 = DataFrame(
+            [[0, 2], [12, 4], [2, np.nan], [4, 5]],
+            columns=["A", "B"],
+            index=[0, 0, 1, 1],
+        )
+        with pytest.raises(ValueError, match=msg):
+            df1.isin(df2)
+
+        # cols and index:
+        df2.columns = ["B", "B"]
+        with pytest.raises(ValueError, match=msg):
+            df1.isin(df2)
+
+    def test_isin_dupe_self(self):
+        other = DataFrame({"A": [1, 0, 1, 0], "B": [1, 1, 0, 0]})
+        df = DataFrame([[1, 1], [1, 0], [0, 0]], columns=["A", "A"])
+        result = df.isin(other)
+        expected = DataFrame(False, index=df.index, columns=df.columns)
+        expected.loc[0] = True
+        expected.iloc[1, 1] = True
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_against_series(self):
+        df = DataFrame(
+            {"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]}, index=["a", "b", "c", "d"]
+        )
+        s = Series([1, 3, 11, 4], index=["a", "b", "c", "d"])
+        expected = DataFrame(False, index=df.index, columns=df.columns)
+        expected.loc["a", "A"] = True
+        expected.loc["d"] = True
+        result = df.isin(s)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_multiIndex(self):
+        idx = MultiIndex.from_tuples(
+            [
+                (0, "a", "foo"),
+                (0, "a", "bar"),
+                (0, "b", "bar"),
+                (0, "b", "baz"),
+                (2, "a", "foo"),
+                (2, "a", "bar"),
+                (2, "c", "bar"),
+                (2, "c", "baz"),
+                (1, "b", "foo"),
+                (1, "b", "bar"),
+                (1, "c", "bar"),
+                (1, "c", "baz"),
+            ]
+        )
+        df1 = DataFrame({"A": np.ones(12), "B": np.zeros(12)}, index=idx)
+        df2 = DataFrame(
+            {
+                "A": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+                "B": [1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1],
+            }
+        )
+        # against regular index
+        expected = DataFrame(False, index=df1.index, columns=df1.columns)
+        result = df1.isin(df2)
+        tm.assert_frame_equal(result, expected)
+
+        df2.index = idx
+        expected = df2.values.astype(bool)
+        expected[:, 1] = ~expected[:, 1]
+        expected = DataFrame(expected, columns=["A", "B"], index=idx)
+
+        result = df1.isin(df2)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_empty_datetimelike(self):
+        # GH#15473
+        df1_ts = DataFrame({"date": pd.to_datetime(["2014-01-01", "2014-01-02"])})
+        df1_td = DataFrame({"date": [pd.Timedelta(1, "s"), pd.Timedelta(2, "s")]})
+        df2 = DataFrame({"date": []})
+        df3 = DataFrame()
+
+        expected = DataFrame({"date": [False, False]})
+
+        result = df1_ts.isin(df2)
+        tm.assert_frame_equal(result, expected)
+        result = df1_ts.isin(df3)
+        tm.assert_frame_equal(result, expected)
+
+        result = df1_td.isin(df2)
+        tm.assert_frame_equal(result, expected)
+        result = df1_td.isin(df3)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            DataFrame({"a": [1, 2, 3]}, dtype="category"),
+            Series([1, 2, 3], dtype="category"),
+        ],
+    )
+    def test_isin_category_frame(self, values):
+        # GH#34256
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        expected = DataFrame({"a": [True, True, True], "b": [False, False, False]})
+
+        result = df.isin(values)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_read_only(self):
+        # https://github.com/pandas-dev/pandas/issues/37174
+        arr = np.array([1, 2, 3])
+        arr.setflags(write=False)
+        df = DataFrame([1, 2, 3])
+        result = df.isin(arr)
+        expected = DataFrame([True, True, True])
+        tm.assert_frame_equal(result, expected)
+
+    def test_isin_not_lossy(self):
+        # GH 53514
+        val = 1666880195890293744
+        df = DataFrame({"a": [val], "b": [1.0]})
+        result = df.isin([val])
+        expected = DataFrame({"a": [True], "b": [False]})
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_iterrows.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_iterrows.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bd0bed76dc9dea5df4d0afb76ebaf0760a23ecc
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_iterrows.py
@@ -0,0 +1,16 @@
+from pandas import (
+    DataFrame,
+    Timedelta,
+)
+
+
+def test_no_overflow_of_freq_and_time_in_dataframe():
+    # GH 35665
+    df = DataFrame(
+        {
+            "some_string": ["2222Y3"],
+            "time": [Timedelta("0 days 00:00:00.990000")],
+        }
+    )
+    for _, row in df.iterrows():
+        assert row.dtype == "object"
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_join.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b6b86056f8c79d7611ffbe399609069a99b7282
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_join.py
@@ -0,0 +1,576 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.errors import MergeError
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.core.reshape.concat import concat
+
+
+@pytest.fixture
+def frame_with_period_index():
+    return DataFrame(
+        data=np.arange(20).reshape(4, 5),
+        columns=list("abcde"),
+        index=period_range(start="2000", freq="A", periods=4),
+    )
+
+
+@pytest.fixture
+def left():
+    return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
+
+
+@pytest.fixture
+def right():
+    return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
+
+
+@pytest.fixture
+def left_no_dup():
+    return DataFrame(
+        {"a": ["a", "b", "c", "d"], "b": ["cat", "dog", "weasel", "horse"]},
+        index=range(4),
+    )
+
+
+@pytest.fixture
+def right_no_dup():
+    return DataFrame(
+        {
+            "a": ["a", "b", "c", "d", "e"],
+            "c": ["meow", "bark", "um... weasel noise?", "nay", "chirp"],
+        },
+        index=range(5),
+    ).set_index("a")
+
+
+@pytest.fixture
+def left_w_dups(left_no_dup):
+    return concat(
+        [left_no_dup, DataFrame({"a": ["a"], "b": ["cow"]}, index=[3])], sort=True
+    )
+
+
+@pytest.fixture
+def right_w_dups(right_no_dup):
+    return concat(
+        [right_no_dup, DataFrame({"a": ["e"], "c": ["moo"]}, index=[3])]
+    ).set_index("a")
+
+
+@pytest.mark.parametrize(
+    "how, sort, expected",
+    [
+        ("inner", False, DataFrame({"a": [20, 10], "b": [200, 100]}, index=[2, 1])),
+        ("inner", True, DataFrame({"a": [10, 20], "b": [100, 200]}, index=[1, 2])),
+        (
+            "left",
+            False,
+            DataFrame({"a": [20, 10, 0], "b": [200, 100, np.nan]}, index=[2, 1, 0]),
+        ),
+        (
+            "left",
+            True,
+            DataFrame({"a": [0, 10, 20], "b": [np.nan, 100, 200]}, index=[0, 1, 2]),
+        ),
+        (
+            "right",
+            False,
+            DataFrame({"a": [np.nan, 10, 20], "b": [300, 100, 200]}, index=[3, 1, 2]),
+        ),
+        (
+            "right",
+            True,
+            DataFrame({"a": [10, 20, np.nan], "b": [100, 200, 300]}, index=[1, 2, 3]),
+        ),
+        (
+            "outer",
+            False,
+            DataFrame(
+                {"a": [0, 10, 20, np.nan], "b": [np.nan, 100, 200, 300]},
+                index=[0, 1, 2, 3],
+            ),
+        ),
+        (
+            "outer",
+            True,
+            DataFrame(
+                {"a": [0, 10, 20, np.nan], "b": [np.nan, 100, 200, 300]},
+                index=[0, 1, 2, 3],
+            ),
+        ),
+    ],
+)
+def test_join(left, right, how, sort, expected):
+    result = left.join(right, how=how, sort=sort, validate="1:1")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_suffix_on_list_join():
+    first = DataFrame({"key": [1, 2, 3, 4, 5]})
+    second = DataFrame({"key": [1, 8, 3, 2, 5], "v1": [1, 2, 3, 4, 5]})
+    third = DataFrame({"keys": [5, 2, 3, 4, 1], "v2": [1, 2, 3, 4, 5]})
+
+    # check proper errors are raised
+    msg = "Suffixes not supported when joining multiple DataFrames"
+    with pytest.raises(ValueError, match=msg):
+        first.join([second], lsuffix="y")
+    with pytest.raises(ValueError, match=msg):
+        first.join([second, third], rsuffix="x")
+    with pytest.raises(ValueError, match=msg):
+        first.join([second, third], lsuffix="y", rsuffix="x")
+    with pytest.raises(ValueError, match="Indexes have overlapping values"):
+        first.join([second, third])
+
+    # no errors should be raised
+    arr_joined = first.join([third])
+    norm_joined = first.join(third)
+    tm.assert_frame_equal(arr_joined, norm_joined)
+
+
+def test_join_invalid_validate(left_no_dup, right_no_dup):
+    # GH 46622
+    # Check invalid arguments
+    msg = (
+        '"invalid" is not a valid argument. '
+        "Valid arguments are:\n"
+        '- "1:1"\n'
+        '- "1:m"\n'
+        '- "m:1"\n'
+        '- "m:m"\n'
+        '- "one_to_one"\n'
+        '- "one_to_many"\n'
+        '- "many_to_one"\n'
+        '- "many_to_many"'
+    )
+    with pytest.raises(ValueError, match=msg):
+        left_no_dup.merge(right_no_dup, on="a", validate="invalid")
+
+
+@pytest.mark.parametrize("dtype", ["object", "string[pyarrow]"])
+def test_join_on_single_col_dup_on_right(left_no_dup, right_w_dups, dtype):
+    # GH 46622
+    # Dups on right allowed by one_to_many constraint
+    if dtype == "string[pyarrow]":
+        pytest.importorskip("pyarrow")
+    left_no_dup = left_no_dup.astype(dtype)
+    right_w_dups.index = right_w_dups.index.astype(dtype)
+    left_no_dup.join(
+        right_w_dups,
+        on="a",
+        validate="one_to_many",
+    )
+
+    # Dups on right not allowed by one_to_one constraint
+    msg = "Merge keys are not unique in right dataset; not a one-to-one merge"
+    with pytest.raises(MergeError, match=msg):
+        left_no_dup.join(
+            right_w_dups,
+            on="a",
+            validate="one_to_one",
+        )
+
+
+def test_join_on_single_col_dup_on_left(left_w_dups, right_no_dup):
+    # GH 46622
+    # Dups on left allowed by many_to_one constraint
+    left_w_dups.join(
+        right_no_dup,
+        on="a",
+        validate="many_to_one",
+    )
+
+    # Dups on left not allowed by one_to_one constraint
+    msg = "Merge keys are not unique in left dataset; not a one-to-one merge"
+    with pytest.raises(MergeError, match=msg):
+        left_w_dups.join(
+            right_no_dup,
+            on="a",
+            validate="one_to_one",
+        )
+
+
+def test_join_on_single_col_dup_on_both(left_w_dups, right_w_dups):
+    # GH 46622
+    # Dups on both allowed by many_to_many constraint
+    left_w_dups.join(right_w_dups, on="a", validate="many_to_many")
+
+    # Dups on both not allowed by many_to_one constraint
+    msg = "Merge keys are not unique in right dataset; not a many-to-one merge"
+    with pytest.raises(MergeError, match=msg):
+        left_w_dups.join(
+            right_w_dups,
+            on="a",
+            validate="many_to_one",
+        )
+
+    # Dups on both not allowed by one_to_many constraint
+    msg = "Merge keys are not unique in left dataset; not a one-to-many merge"
+    with pytest.raises(MergeError, match=msg):
+        left_w_dups.join(
+            right_w_dups,
+            on="a",
+            validate="one_to_many",
+        )
+
+
+def test_join_on_multi_col_check_dup():
+    # GH 46622
+    # Two column join, dups in both, but jointly no dups
+    left = DataFrame(
+        {
+            "a": ["a", "a", "b", "b"],
+            "b": [0, 1, 0, 1],
+            "c": ["cat", "dog", "weasel", "horse"],
+        },
+        index=range(4),
+    ).set_index(["a", "b"])
+
+    right = DataFrame(
+        {
+            "a": ["a", "a", "b"],
+            "b": [0, 1, 0],
+            "d": ["meow", "bark", "um... weasel noise?"],
+        },
+        index=range(3),
+    ).set_index(["a", "b"])
+
+    expected_multi = DataFrame(
+        {
+            "a": ["a", "a", "b"],
+            "b": [0, 1, 0],
+            "c": ["cat", "dog", "weasel"],
+            "d": ["meow", "bark", "um... weasel noise?"],
+        },
+        index=range(3),
+    ).set_index(["a", "b"])
+
+    # Jointly no dups allowed by one_to_one constraint
+    result = left.join(right, how="inner", validate="1:1")
+    tm.assert_frame_equal(result, expected_multi)
+
+
+def test_join_index(float_frame):
+    # left / right
+
+    f = float_frame.loc[float_frame.index[:10], ["A", "B"]]
+    f2 = float_frame.loc[float_frame.index[5:], ["C", "D"]].iloc[::-1]
+
+    joined = f.join(f2)
+    tm.assert_index_equal(f.index, joined.index)
+    expected_columns = Index(["A", "B", "C", "D"])
+    tm.assert_index_equal(joined.columns, expected_columns)
+
+    joined = f.join(f2, how="left")
+    tm.assert_index_equal(joined.index, f.index)
+    tm.assert_index_equal(joined.columns, expected_columns)
+
+    joined = f.join(f2, how="right")
+    tm.assert_index_equal(joined.index, f2.index)
+    tm.assert_index_equal(joined.columns, expected_columns)
+
+    # inner
+
+    joined = f.join(f2, how="inner")
+    tm.assert_index_equal(joined.index, f.index[5:10])
+    tm.assert_index_equal(joined.columns, expected_columns)
+
+    # outer
+
+    joined = f.join(f2, how="outer")
+    tm.assert_index_equal(joined.index, float_frame.index.sort_values())
+    tm.assert_index_equal(joined.columns, expected_columns)
+
+    with pytest.raises(ValueError, match="join method"):
+        f.join(f2, how="foo")
+
+    # corner case - overlapping columns
+    msg = "columns overlap but no suffix"
+    for how in ("outer", "left", "inner"):
+        with pytest.raises(ValueError, match=msg):
+            float_frame.join(float_frame, how=how)
+
+
+def test_join_index_more(float_frame):
+    af = float_frame.loc[:, ["A", "B"]]
+    bf = float_frame.loc[::2, ["C", "D"]]
+
+    expected = af.copy()
+    expected["C"] = float_frame["C"][::2]
+    expected["D"] = float_frame["D"][::2]
+
+    result = af.join(bf)
+    tm.assert_frame_equal(result, expected)
+
+    result = af.join(bf, how="right")
+    tm.assert_frame_equal(result, expected[::2])
+
+    result = bf.join(af, how="right")
+    tm.assert_frame_equal(result, expected.loc[:, result.columns])
+
+
+def test_join_index_series(float_frame):
+    df = float_frame.copy()
+    ser = df.pop(float_frame.columns[-1])
+    joined = df.join(ser)
+
+    tm.assert_frame_equal(joined, float_frame)
+
+    ser.name = None
+    with pytest.raises(ValueError, match="must have a name"):
+        df.join(ser)
+
+
+def test_join_overlap(float_frame):
+    df1 = float_frame.loc[:, ["A", "B", "C"]]
+    df2 = float_frame.loc[:, ["B", "C", "D"]]
+
+    joined = df1.join(df2, lsuffix="_df1", rsuffix="_df2")
+    df1_suf = df1.loc[:, ["B", "C"]].add_suffix("_df1")
+    df2_suf = df2.loc[:, ["B", "C"]].add_suffix("_df2")
+
+    no_overlap = float_frame.loc[:, ["A", "D"]]
+    expected = df1_suf.join(df2_suf).join(no_overlap)
+
+    # column order not necessarily sorted
+    tm.assert_frame_equal(joined, expected.loc[:, joined.columns])
+
+
+def test_join_period_index(frame_with_period_index):
+    other = frame_with_period_index.rename(columns=lambda key: f"{key}{key}")
+
+    joined_values = np.concatenate([frame_with_period_index.values] * 2, axis=1)
+
+    joined_cols = frame_with_period_index.columns.append(other.columns)
+
+    joined = frame_with_period_index.join(other)
+    expected = DataFrame(
+        data=joined_values, columns=joined_cols, index=frame_with_period_index.index
+    )
+
+    tm.assert_frame_equal(joined, expected)
+
+
+def test_join_left_sequence_non_unique_index():
+    # https://github.com/pandas-dev/pandas/issues/19607
+    df1 = DataFrame({"a": [0, 10, 20]}, index=[1, 2, 3])
+    df2 = DataFrame({"b": [100, 200, 300]}, index=[4, 3, 2])
+    df3 = DataFrame({"c": [400, 500, 600]}, index=[2, 2, 4])
+
+    joined = df1.join([df2, df3], how="left")
+
+    expected = DataFrame(
+        {
+            "a": [0, 10, 10, 20],
+            "b": [np.nan, 300, 300, 200],
+            "c": [np.nan, 400, 500, np.nan],
+        },
+        index=[1, 2, 2, 3],
+    )
+
+    tm.assert_frame_equal(joined, expected)
+
+
+def test_join_list_series(float_frame):
+    # GH#46850
+    # Join a DataFrame with a list containing both a Series and a DataFrame
+    left = float_frame.A.to_frame()
+    right = [float_frame.B, float_frame[["C", "D"]]]
+    result = left.join(right)
+    tm.assert_frame_equal(result, float_frame)
+
+
+@pytest.mark.parametrize("sort_kw", [True, False])
+def test_suppress_future_warning_with_sort_kw(sort_kw):
+    a = DataFrame({"col1": [1, 2]}, index=["c", "a"])
+
+    b = DataFrame({"col2": [4, 5]}, index=["b", "a"])
+
+    c = DataFrame({"col3": [7, 8]}, index=["a", "b"])
+
+    expected = DataFrame(
+        {
+            "col1": {"a": 2.0, "b": float("nan"), "c": 1.0},
+            "col2": {"a": 5.0, "b": 4.0, "c": float("nan")},
+            "col3": {"a": 7.0, "b": 8.0, "c": float("nan")},
+        }
+    )
+    if sort_kw is False:
+        expected = expected.reindex(index=["c", "a", "b"])
+
+    with tm.assert_produces_warning(None):
+        result = a.join([b, c], how="outer", sort=sort_kw)
+    tm.assert_frame_equal(result, expected)
+
+
+class TestDataFrameJoin:
+    def test_join(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        a = frame.loc[frame.index[:5], ["A"]]
+        b = frame.loc[frame.index[2:], ["B", "C"]]
+
+        joined = a.join(b, how="outer").reindex(frame.index)
+        expected = frame.copy().values.copy()
+        expected[np.isnan(joined.values)] = np.nan
+        expected = DataFrame(expected, index=frame.index, columns=frame.columns)
+
+        assert not np.isnan(joined.values).all()
+
+        tm.assert_frame_equal(joined, expected)
+
+    def test_join_segfault(self):
+        # GH#1532
+        df1 = DataFrame({"a": [1, 1], "b": [1, 2], "x": [1, 2]})
+        df2 = DataFrame({"a": [2, 2], "b": [1, 2], "y": [1, 2]})
+        df1 = df1.set_index(["a", "b"])
+        df2 = df2.set_index(["a", "b"])
+        # it works!
+        for how in ["left", "right", "outer"]:
+            df1.join(df2, how=how)
+
+    def test_join_str_datetime(self):
+        str_dates = ["20120209", "20120222"]
+        dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)]
+
+        A = DataFrame(str_dates, index=range(2), columns=["aa"])
+        C = DataFrame([[1, 2], [3, 4]], index=str_dates, columns=dt_dates)
+
+        tst = A.join(C, on="aa")
+
+        assert len(tst.columns) == 3
+
+    def test_join_multiindex_leftright(self):
+        # GH 10741
+        df1 = DataFrame(
+            [
+                ["a", "x", 0.471780],
+                ["a", "y", 0.774908],
+                ["a", "z", 0.563634],
+                ["b", "x", -0.353756],
+                ["b", "y", 0.368062],
+                ["b", "z", -1.721840],
+                ["c", "x", 1],
+                ["c", "y", 2],
+                ["c", "z", 3],
+            ],
+            columns=["first", "second", "value1"],
+        ).set_index(["first", "second"])
+
+        df2 = DataFrame([["a", 10], ["b", 20]], columns=["first", "value2"]).set_index(
+            ["first"]
+        )
+
+        exp = DataFrame(
+            [
+                [0.471780, 10],
+                [0.774908, 10],
+                [0.563634, 10],
+                [-0.353756, 20],
+                [0.368062, 20],
+                [-1.721840, 20],
+                [1.000000, np.nan],
+                [2.000000, np.nan],
+                [3.000000, np.nan],
+            ],
+            index=df1.index,
+            columns=["value1", "value2"],
+        )
+
+        # these must be the same results (but columns are flipped)
+        tm.assert_frame_equal(df1.join(df2, how="left"), exp)
+        tm.assert_frame_equal(df2.join(df1, how="right"), exp[["value2", "value1"]])
+
+        exp_idx = MultiIndex.from_product(
+            [["a", "b"], ["x", "y", "z"]], names=["first", "second"]
+        )
+        exp = DataFrame(
+            [
+                [0.471780, 10],
+                [0.774908, 10],
+                [0.563634, 10],
+                [-0.353756, 20],
+                [0.368062, 20],
+                [-1.721840, 20],
+            ],
+            index=exp_idx,
+            columns=["value1", "value2"],
+        )
+
+        tm.assert_frame_equal(df1.join(df2, how="right"), exp)
+        tm.assert_frame_equal(df2.join(df1, how="left"), exp[["value2", "value1"]])
+
+    def test_join_multiindex_dates(self):
+        # GH 33692
+        date = pd.Timestamp(2000, 1, 1).date()
+
+        df1_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        df1 = DataFrame({"col1": [0]}, index=df1_index)
+        df2_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        df2 = DataFrame({"col2": [0]}, index=df2_index)
+        df3_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        df3 = DataFrame({"col3": [0]}, index=df3_index)
+
+        result = df1.join([df2, df3])
+
+        expected_index = MultiIndex.from_tuples([(0, date)], names=["index_0", "date"])
+        expected = DataFrame(
+            {"col1": [0], "col2": [0], "col3": [0]}, index=expected_index
+        )
+
+        tm.assert_equal(result, expected)
+
+    def test_merge_join_different_levels_raises(self):
+        # GH#9455
+        # GH 40993: For raising, enforced in 2.0
+
+        # first dataframe
+        df1 = DataFrame(columns=["a", "b"], data=[[1, 11], [0, 22]])
+
+        # second dataframe
+        columns = MultiIndex.from_tuples([("a", ""), ("c", "c1")])
+        df2 = DataFrame(columns=columns, data=[[1, 33], [0, 44]])
+
+        # merge
+        with pytest.raises(
+            MergeError, match="Not allowed to merge between different levels"
+        ):
+            pd.merge(df1, df2, on="a")
+
+        # join, see discussion in GH#12219
+        with pytest.raises(
+            MergeError, match="Not allowed to merge between different levels"
+        ):
+            df1.join(df2, on="a")
+
+    def test_frame_join_tzaware(self):
+        test1 = DataFrame(
+            np.zeros((6, 3)),
+            index=date_range(
+                "2012-11-15 00:00:00", periods=6, freq="100L", tz="US/Central"
+            ),
+        )
+        test2 = DataFrame(
+            np.zeros((3, 3)),
+            index=date_range(
+                "2012-11-15 00:00:00", periods=3, freq="250L", tz="US/Central"
+            ),
+            columns=range(3, 6),
+        )
+
+        result = test1.join(test2, how="outer")
+        expected = test1.index.union(test2.index)
+
+        tm.assert_index_equal(result.index, expected)
+        assert result.index.tz.zone == "US/Central"
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_map.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..0de88114af1993f77147ae3e8342e45df1438053
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_map.py
@@ -0,0 +1,216 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def test_map(float_frame):
+    result = float_frame.map(lambda x: x * 2)
+    tm.assert_frame_equal(result, float_frame * 2)
+    float_frame.map(type)
+
+    # GH 465: function returning tuples
+    result = float_frame.map(lambda x: (x, x))["A"].iloc[0]
+    assert isinstance(result, tuple)
+
+
+@pytest.mark.parametrize("val", [1, 1.0])
+def test_map_float_object_conversion(val):
+    # GH 2909: object conversion to float in constructor?
+    df = DataFrame(data=[val, "a"])
+    result = df.map(lambda x: x).dtypes[0]
+    assert result == object
+
+
+@pytest.mark.parametrize("na_action", [None, "ignore"])
+def test_map_keeps_dtype(na_action):
+    # GH52219
+    arr = Series(["a", np.nan, "b"])
+    sparse_arr = arr.astype(pd.SparseDtype(object))
+    df = DataFrame(data={"a": arr, "b": sparse_arr})
+
+    def func(x):
+        return str.upper(x) if not pd.isna(x) else x
+
+    result = df.map(func, na_action=na_action)
+
+    expected_sparse = pd.array(["A", np.nan, "B"], dtype=pd.SparseDtype(object))
+    expected_arr = expected_sparse.astype(object)
+    expected = DataFrame({"a": expected_arr, "b": expected_sparse})
+
+    tm.assert_frame_equal(result, expected)
+
+    result_empty = df.iloc[:0, :].map(func, na_action=na_action)
+    expected_empty = expected.iloc[:0, :]
+    tm.assert_frame_equal(result_empty, expected_empty)
+
+
+def test_map_str():
+    # GH 2786
+    df = DataFrame(np.random.default_rng(2).random((3, 4)))
+    df2 = df.copy()
+    cols = ["a", "a", "a", "a"]
+    df.columns = cols
+
+    expected = df2.map(str)
+    expected.columns = cols
+    result = df.map(str)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "col, val",
+    [["datetime", Timestamp("20130101")], ["timedelta", pd.Timedelta("1 min")]],
+)
+def test_map_datetimelike(col, val):
+    # datetime/timedelta
+    df = DataFrame(np.random.default_rng(2).random((3, 4)))
+    df[col] = val
+    result = df.map(str)
+    assert result.loc[0, col] == str(df.loc[0, col])
+
+
+@pytest.mark.parametrize(
+    "expected",
+    [
+        DataFrame(),
+        DataFrame(columns=list("ABC")),
+        DataFrame(index=list("ABC")),
+        DataFrame({"A": [], "B": [], "C": []}),
+    ],
+)
+@pytest.mark.parametrize("func", [round, lambda x: x])
+def test_map_empty(expected, func):
+    # GH 8222
+    result = expected.map(func)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_map_kwargs():
+    # GH 40652
+    result = DataFrame([[1, 2], [3, 4]]).map(lambda x, y: x + y, y=2)
+    expected = DataFrame([[3, 4], [5, 6]])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_map_na_ignore(float_frame):
+    # GH 23803
+    strlen_frame = float_frame.map(lambda x: len(str(x)))
+    float_frame_with_na = float_frame.copy()
+    mask = np.random.default_rng(2).integers(0, 2, size=float_frame.shape, dtype=bool)
+    float_frame_with_na[mask] = pd.NA
+    strlen_frame_na_ignore = float_frame_with_na.map(
+        lambda x: len(str(x)), na_action="ignore"
+    )
+    # Set float64 type to avoid upcast when setting NA below
+    strlen_frame_with_na = strlen_frame.copy().astype("float64")
+    strlen_frame_with_na[mask] = pd.NA
+    tm.assert_frame_equal(strlen_frame_na_ignore, strlen_frame_with_na)
+
+
+def test_map_box_timestamps():
+    # GH 2689, GH 2627
+    ser = Series(date_range("1/1/2000", periods=10))
+
+    def func(x):
+        return (x.hour, x.day, x.month)
+
+    # it works!
+    DataFrame(ser).map(func)
+
+
+def test_map_box():
+    # ufunc will not be boxed. Same test cases as the test_map_box
+    df = DataFrame(
+        {
+            "a": [Timestamp("2011-01-01"), Timestamp("2011-01-02")],
+            "b": [
+                Timestamp("2011-01-01", tz="US/Eastern"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+            ],
+            "c": [pd.Timedelta("1 days"), pd.Timedelta("2 days")],
+            "d": [
+                pd.Period("2011-01-01", freq="M"),
+                pd.Period("2011-01-02", freq="M"),
+            ],
+        }
+    )
+
+    result = df.map(lambda x: type(x).__name__)
+    expected = DataFrame(
+        {
+            "a": ["Timestamp", "Timestamp"],
+            "b": ["Timestamp", "Timestamp"],
+            "c": ["Timedelta", "Timedelta"],
+            "d": ["Period", "Period"],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_frame_map_dont_convert_datetime64():
+    from pandas.tseries.offsets import BDay
+
+    df = DataFrame({"x1": [datetime(1996, 1, 1)]})
+
+    df = df.map(lambda x: x + BDay())
+    df = df.map(lambda x: x + BDay())
+
+    result = df.x1.dtype
+    assert result == "M8[ns]"
+
+
+def test_map_function_runs_once():
+    df = DataFrame({"a": [1, 2, 3]})
+    values = []  # Save values function is applied to
+
+    def reducing_function(val):
+        values.append(val)
+
+    def non_reducing_function(val):
+        values.append(val)
+        return val
+
+    for func in [reducing_function, non_reducing_function]:
+        del values[:]
+
+        df.map(func)
+        assert values == df.a.to_list()
+
+
+def test_map_type():
+    # GH 46719
+    df = DataFrame(
+        {"col1": [3, "string", float], "col2": [0.25, datetime(2020, 1, 1), np.nan]},
+        index=["a", "b", "c"],
+    )
+
+    result = df.map(type)
+    expected = DataFrame(
+        {"col1": [int, str, type], "col2": [float, datetime, float]},
+        index=["a", "b", "c"],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_map_invalid_na_action(float_frame):
+    # GH 23803
+    with pytest.raises(ValueError, match="na_action must be .*Got 'abc'"):
+        float_frame.map(lambda x: len(str(x)), na_action="abc")
+
+
+def test_applymap_deprecated():
+    # GH52353
+    df = DataFrame({"a": [1, 2, 3]})
+    msg = "DataFrame.applymap has been deprecated. Use DataFrame.map instead."
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.applymap(lambda x: x)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_matmul.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_matmul.py
new file mode 100644
index 0000000000000000000000000000000000000000..be9462b64fa1b919b13772e9d07727258931b952
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_matmul.py
@@ -0,0 +1,98 @@
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestMatMul:
+    def test_matmul(self):
+        # matmul test is for GH#10259
+        a = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            index=["a", "b", "c"],
+            columns=["p", "q", "r", "s"],
+        )
+        b = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 2)),
+            index=["p", "q", "r", "s"],
+            columns=["one", "two"],
+        )
+
+        # DataFrame @ DataFrame
+        result = operator.matmul(a, b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # DataFrame @ Series
+        result = operator.matmul(a, b.one)
+        expected = Series(np.dot(a.values, b.one.values), index=["a", "b", "c"])
+        tm.assert_series_equal(result, expected)
+
+        # np.array @ DataFrame
+        result = operator.matmul(a.values, b)
+        assert isinstance(result, DataFrame)
+        assert result.columns.equals(b.columns)
+        assert result.index.equals(Index(range(3)))
+        expected = np.dot(a.values, b.values)
+        tm.assert_almost_equal(result.values, expected)
+
+        # nested list @ DataFrame (__rmatmul__)
+        result = operator.matmul(a.values.tolist(), b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_almost_equal(result.values, expected.values)
+
+        # mixed dtype DataFrame @ DataFrame
+        a["q"] = a.q.round().astype(int)
+        result = operator.matmul(a, b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # different dtypes DataFrame @ DataFrame
+        a = a.astype(int)
+        result = operator.matmul(a, b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # unaligned
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            index=[1, 2, 3],
+            columns=range(4),
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 3)),
+            index=range(5),
+            columns=[1, 2, 3],
+        )
+
+        with pytest.raises(ValueError, match="aligned"):
+            operator.matmul(df, df2)
+
+    def test_matmul_message_shapes(self):
+        # GH#21581 exception message should reflect original shapes,
+        #  not transposed shapes
+        a = np.random.default_rng(2).random((10, 4))
+        b = np.random.default_rng(2).random((5, 3))
+
+        df = DataFrame(b)
+
+        msg = r"shapes \(10, 4\) and \(5, 3\) not aligned"
+        with pytest.raises(ValueError, match=msg):
+            a @ df
+        with pytest.raises(ValueError, match=msg):
+            a.tolist() @ df
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_nlargest.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_nlargest.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bdf9a0e5c007cdccbf8a2cb3cda1784b993c751
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_nlargest.py
@@ -0,0 +1,250 @@
+"""
+Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
+but are implicitly also testing nsmallest_foo.
+"""
+from string import ascii_lowercase
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.util.version import Version
+
+
+@pytest.fixture
+def df_duplicates():
+    return pd.DataFrame(
+        {"a": [1, 2, 3, 4, 4], "b": [1, 1, 1, 1, 1], "c": [0, 1, 2, 5, 4]},
+        index=[0, 0, 1, 1, 1],
+    )
+
+
+@pytest.fixture
+def df_strings():
+    return pd.DataFrame(
+        {
+            "a": np.random.default_rng(2).permutation(10),
+            "b": list(ascii_lowercase[:10]),
+            "c": np.random.default_rng(2).permutation(10).astype("float64"),
+        }
+    )
+
+
+@pytest.fixture
+def df_main_dtypes():
+    return pd.DataFrame(
+        {
+            "group": [1, 1, 2],
+            "int": [1, 2, 3],
+            "float": [4.0, 5.0, 6.0],
+            "string": list("abc"),
+            "category_string": pd.Series(list("abc")).astype("category"),
+            "category_int": [7, 8, 9],
+            "datetime": pd.date_range("20130101", periods=3),
+            "datetimetz": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+            "timedelta": pd.timedelta_range("1 s", periods=3, freq="s"),
+        },
+        columns=[
+            "group",
+            "int",
+            "float",
+            "string",
+            "category_string",
+            "category_int",
+            "datetime",
+            "datetimetz",
+            "timedelta",
+        ],
+    )
+
+
+class TestNLargestNSmallest:
+    # ----------------------------------------------------------------------
+    # Top / bottom
+    @pytest.mark.parametrize(
+        "order",
+        [
+            ["a"],
+            ["c"],
+            ["a", "b"],
+            ["a", "c"],
+            ["b", "a"],
+            ["b", "c"],
+            ["a", "b", "c"],
+            ["c", "a", "b"],
+            ["c", "b", "a"],
+            ["b", "c", "a"],
+            ["b", "a", "c"],
+            # dups!
+            ["b", "c", "c"],
+        ],
+    )
+    @pytest.mark.parametrize("n", range(1, 11))
+    def test_nlargest_n(self, df_strings, nselect_method, n, order):
+        # GH#10393
+        df = df_strings
+        if "b" in order:
+            error_msg = (
+                f"Column 'b' has dtype object, "
+                f"cannot use method '{nselect_method}' with this dtype"
+            )
+            with pytest.raises(TypeError, match=error_msg):
+                getattr(df, nselect_method)(n, order)
+        else:
+            ascending = nselect_method == "nsmallest"
+            result = getattr(df, nselect_method)(n, order)
+            expected = df.sort_values(order, ascending=ascending).head(n)
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "columns", [["group", "category_string"], ["group", "string"]]
+    )
+    def test_nlargest_error(self, df_main_dtypes, nselect_method, columns):
+        df = df_main_dtypes
+        col = columns[1]
+        error_msg = (
+            f"Column '{col}' has dtype {df[col].dtype}, "
+            f"cannot use method '{nselect_method}' with this dtype"
+        )
+        # escape some characters that may be in the repr
+        error_msg = (
+            error_msg.replace("(", "\\(")
+            .replace(")", "\\)")
+            .replace("[", "\\[")
+            .replace("]", "\\]")
+        )
+        with pytest.raises(TypeError, match=error_msg):
+            getattr(df, nselect_method)(2, columns)
+
+    def test_nlargest_all_dtypes(self, df_main_dtypes):
+        df = df_main_dtypes
+        df.nsmallest(2, list(set(df) - {"category_string", "string"}))
+        df.nlargest(2, list(set(df) - {"category_string", "string"}))
+
+    def test_nlargest_duplicates_on_starter_columns(self):
+        # regression test for GH#22752
+
+        df = pd.DataFrame({"a": [2, 2, 2, 1, 1, 1], "b": [1, 2, 3, 3, 2, 1]})
+
+        result = df.nlargest(4, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {"a": [2, 2, 2, 1], "b": [3, 2, 1, 3]}, index=[2, 1, 0, 3]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(4, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {"a": [1, 1, 1, 2], "b": [1, 2, 3, 1]}, index=[5, 4, 3, 0]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_n_identical_values(self):
+        # GH#15297
+        df = pd.DataFrame({"a": [1] * 5, "b": [1, 2, 3, 4, 5]})
+
+        result = df.nlargest(3, "a")
+        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]}, index=[0, 1, 2])
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(3, "a")
+        expected = pd.DataFrame({"a": [1] * 3, "b": [1, 2, 3]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "order",
+        [["a", "b", "c"], ["c", "b", "a"], ["a"], ["b"], ["a", "b"], ["c", "b"]],
+    )
+    @pytest.mark.parametrize("n", range(1, 6))
+    def test_nlargest_n_duplicate_index(self, df_duplicates, n, order, request):
+        # GH#13412
+
+        df = df_duplicates
+        result = df.nsmallest(n, order)
+        expected = df.sort_values(order).head(n)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nlargest(n, order)
+        expected = df.sort_values(order, ascending=False).head(n)
+        if Version(np.__version__) >= Version("1.25") and (
+            (order == ["a"] and n in (1, 2, 3, 4)) or (order == ["a", "b"]) and n == 5
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        "pandas default unstable sorting of duplicates"
+                        "issue with numpy>=1.25 with AVX instructions"
+                    ),
+                    strict=False,
+                )
+            )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_duplicate_keep_all_ties(self):
+        # GH#16818
+        df = pd.DataFrame(
+            {"a": [5, 4, 4, 2, 3, 3, 3, 3], "b": [10, 9, 8, 7, 5, 50, 10, 20]}
+        )
+        result = df.nlargest(4, "a", keep="all")
+        expected = pd.DataFrame(
+            {
+                "a": {0: 5, 1: 4, 2: 4, 4: 3, 5: 3, 6: 3, 7: 3},
+                "b": {0: 10, 1: 9, 2: 8, 4: 5, 5: 50, 6: 10, 7: 20},
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.nsmallest(2, "a", keep="all")
+        expected = pd.DataFrame(
+            {
+                "a": {3: 2, 4: 3, 5: 3, 6: 3, 7: 3},
+                "b": {3: 7, 4: 5, 5: 50, 6: 10, 7: 20},
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_multiindex_column_lookup(self):
+        # Check whether tuples are correctly treated as multi-level lookups.
+        # GH#23033
+        df = pd.DataFrame(
+            columns=pd.MultiIndex.from_product([["x"], ["a", "b"]]),
+            data=[[0.33, 0.13], [0.86, 0.25], [0.25, 0.70], [0.85, 0.91]],
+        )
+
+        # nsmallest
+        result = df.nsmallest(3, ("x", "a"))
+        expected = df.iloc[[2, 0, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        # nlargest
+        result = df.nlargest(3, ("x", "b"))
+        expected = df.iloc[[3, 2, 1]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_nlargest_nan(self):
+        # GH#43060
+        df = pd.DataFrame([np.nan, np.nan, 0, 1, 2, 3])
+        result = df.nlargest(5, 0)
+        expected = df.sort_values(0, ascending=False).head(5)
+        tm.assert_frame_equal(result, expected)
+
+    def test_nsmallest_nan_after_n_element(self):
+        # GH#46589
+        df = pd.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5, None, 7],
+                "b": [7, 6, 5, 4, 3, 2, 1],
+                "c": [1, 1, 2, 2, 3, 3, 3],
+            },
+            index=range(7),
+        )
+        result = df.nsmallest(5, columns=["a", "b"])
+        expected = pd.DataFrame(
+            {
+                "a": [1, 2, 3, 4, 5],
+                "b": [7, 6, 5, 4, 3],
+                "c": [1, 1, 2, 2, 3],
+            },
+            index=range(5),
+        ).astype({"a": "float"})
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pct_change.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pct_change.py
new file mode 100644
index 0000000000000000000000000000000000000000..92b66e12d4356ca33d6351b092e3655541c9e8bb
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pct_change.py
@@ -0,0 +1,180 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFramePctChange:
+    @pytest.mark.parametrize(
+        "periods, fill_method, limit, exp",
+        [
+            (1, "ffill", None, [np.nan, np.nan, np.nan, 1, 1, 1.5, 0, 0]),
+            (1, "ffill", 1, [np.nan, np.nan, np.nan, 1, 1, 1.5, 0, np.nan]),
+            (1, "bfill", None, [np.nan, 0, 0, 1, 1, 1.5, np.nan, np.nan]),
+            (1, "bfill", 1, [np.nan, np.nan, 0, 1, 1, 1.5, np.nan, np.nan]),
+            (-1, "ffill", None, [np.nan, np.nan, -0.5, -0.5, -0.6, 0, 0, np.nan]),
+            (-1, "ffill", 1, [np.nan, np.nan, -0.5, -0.5, -0.6, 0, np.nan, np.nan]),
+            (-1, "bfill", None, [0, 0, -0.5, -0.5, -0.6, np.nan, np.nan, np.nan]),
+            (-1, "bfill", 1, [np.nan, 0, -0.5, -0.5, -0.6, np.nan, np.nan, np.nan]),
+        ],
+    )
+    def test_pct_change_with_nas(
+        self, periods, fill_method, limit, exp, frame_or_series
+    ):
+        vals = [np.nan, np.nan, 1, 2, 4, 10, np.nan, np.nan]
+        obj = frame_or_series(vals)
+
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            f"{type(obj).__name__}.pct_change are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = obj.pct_change(periods=periods, fill_method=fill_method, limit=limit)
+        tm.assert_equal(res, frame_or_series(exp))
+
+    def test_pct_change_numeric(self):
+        # GH#11150
+        pnl = DataFrame(
+            [np.arange(0, 40, 10), np.arange(0, 40, 10), np.arange(0, 40, 10)]
+        ).astype(np.float64)
+        pnl.iat[1, 0] = np.nan
+        pnl.iat[1, 1] = np.nan
+        pnl.iat[2, 3] = 60
+
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "DataFrame.pct_change are deprecated"
+        )
+
+        for axis in range(2):
+            expected = pnl.ffill(axis=axis) / pnl.ffill(axis=axis).shift(axis=axis) - 1
+
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                result = pnl.pct_change(axis=axis, fill_method="pad")
+            tm.assert_frame_equal(result, expected)
+
+    def test_pct_change(self, datetime_frame):
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "DataFrame.pct_change are deprecated"
+        )
+
+        rs = datetime_frame.pct_change(fill_method=None)
+        tm.assert_frame_equal(rs, datetime_frame / datetime_frame.shift(1) - 1)
+
+        rs = datetime_frame.pct_change(2)
+        filled = datetime_frame.ffill()
+        tm.assert_frame_equal(rs, filled / filled.shift(2) - 1)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = datetime_frame.pct_change(fill_method="bfill", limit=1)
+        filled = datetime_frame.bfill(limit=1)
+        tm.assert_frame_equal(rs, filled / filled.shift(1) - 1)
+
+        rs = datetime_frame.pct_change(freq="5D")
+        filled = datetime_frame.ffill()
+        tm.assert_frame_equal(
+            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
+        )
+
+    def test_pct_change_shift_over_nas(self):
+        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
+
+        df = DataFrame({"a": s, "b": s})
+
+        msg = "The default fill_method='pad' in DataFrame.pct_change is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            chg = df.pct_change()
+
+        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
+        edf = DataFrame({"a": expected, "b": expected})
+        tm.assert_frame_equal(chg, edf)
+
+    @pytest.mark.parametrize(
+        "freq, periods, fill_method, limit",
+        [
+            ("5B", 5, None, None),
+            ("3B", 3, None, None),
+            ("3B", 3, "bfill", None),
+            ("7B", 7, "pad", 1),
+            ("7B", 7, "bfill", 3),
+            ("14B", 14, None, None),
+        ],
+    )
+    def test_pct_change_periods_freq(
+        self, datetime_frame, freq, periods, fill_method, limit
+    ):
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "DataFrame.pct_change are deprecated"
+        )
+
+        # GH#7292
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_freq = datetime_frame.pct_change(
+                freq=freq, fill_method=fill_method, limit=limit
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_periods = datetime_frame.pct_change(
+                periods, fill_method=fill_method, limit=limit
+            )
+        tm.assert_frame_equal(rs_freq, rs_periods)
+
+        empty_ts = DataFrame(index=datetime_frame.index, columns=datetime_frame.columns)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_freq = empty_ts.pct_change(
+                freq=freq, fill_method=fill_method, limit=limit
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_periods = empty_ts.pct_change(
+                periods, fill_method=fill_method, limit=limit
+            )
+        tm.assert_frame_equal(rs_freq, rs_periods)
+
+
+@pytest.mark.parametrize("fill_method", ["pad", "ffill", None])
+def test_pct_change_with_duplicated_indices(fill_method):
+    # GH30463
+    data = DataFrame(
+        {0: [np.nan, 1, 2, 3, 9, 18], 1: [0, 1, np.nan, 3, 9, 18]}, index=["a", "b"] * 3
+    )
+
+    warn = None if fill_method is None else FutureWarning
+    msg = (
+        "The 'fill_method' keyword being not None and the 'limit' keyword in "
+        "DataFrame.pct_change are deprecated"
+    )
+    with tm.assert_produces_warning(warn, match=msg):
+        result = data.pct_change(fill_method=fill_method)
+
+    if fill_method is None:
+        second_column = [np.nan, np.inf, np.nan, np.nan, 2.0, 1.0]
+    else:
+        second_column = [np.nan, np.inf, 0.0, 2.0, 2.0, 1.0]
+    expected = DataFrame(
+        {0: [np.nan, np.nan, 1.0, 0.5, 2.0, 1.0], 1: second_column},
+        index=["a", "b"] * 3,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_pct_change_none_beginning_no_warning():
+    # GH#54481
+    df = DataFrame(
+        [
+            [1, None],
+            [2, 1],
+            [3, 2],
+            [4, 3],
+            [5, 4],
+        ]
+    )
+    result = df.pct_change()
+    expected = DataFrame(
+        {0: [np.nan, 1, 0.5, 1 / 3, 0.25], 1: [np.nan, np.nan, 1, 0.5, 1 / 3]}
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pipe.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pipe.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bcc4360487f38491e2ae9f4c79d837e72ed0f6d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pipe.py
@@ -0,0 +1,39 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestPipe:
+    def test_pipe(self, frame_or_series):
+        obj = DataFrame({"A": [1, 2, 3]})
+        expected = DataFrame({"A": [1, 4, 9]})
+        if frame_or_series is Series:
+            obj = obj["A"]
+            expected = expected["A"]
+
+        f = lambda x, y: x**y
+        result = obj.pipe(f, 2)
+        tm.assert_equal(result, expected)
+
+    def test_pipe_tuple(self, frame_or_series):
+        obj = DataFrame({"A": [1, 2, 3]})
+        obj = tm.get_obj(obj, frame_or_series)
+
+        f = lambda x, y: y
+        result = obj.pipe((f, "y"), 0)
+        tm.assert_equal(result, obj)
+
+    def test_pipe_tuple_error(self, frame_or_series):
+        obj = DataFrame({"A": [1, 2, 3]})
+        obj = tm.get_obj(obj, frame_or_series)
+
+        f = lambda x, y: y
+
+        msg = "y is both the pipe target and a keyword argument"
+
+        with pytest.raises(ValueError, match=msg):
+            obj.pipe((f, "y"), x=1, y=0)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pop.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pop.py
new file mode 100644
index 0000000000000000000000000000000000000000..617f0c3a2788580274a44db6edb292cba17110fc
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_pop.py
@@ -0,0 +1,71 @@
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestDataFramePop:
+    def test_pop(self, float_frame):
+        float_frame.columns.name = "baz"
+
+        float_frame.pop("A")
+        assert "A" not in float_frame
+
+        float_frame["foo"] = "bar"
+        float_frame.pop("foo")
+        assert "foo" not in float_frame
+        assert float_frame.columns.name == "baz"
+
+        # gh-10912: inplace ops cause caching issue
+        a = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"], index=["X", "Y"])
+        b = a.pop("B")
+        b += 1
+
+        # original frame
+        expected = DataFrame([[1, 3], [4, 6]], columns=["A", "C"], index=["X", "Y"])
+        tm.assert_frame_equal(a, expected)
+
+        # result
+        expected = Series([2, 5], index=["X", "Y"], name="B") + 1
+        tm.assert_series_equal(b, expected)
+
+    def test_pop_non_unique_cols(self):
+        df = DataFrame({0: [0, 1], 1: [0, 1], 2: [4, 5]})
+        df.columns = ["a", "b", "a"]
+
+        res = df.pop("a")
+        assert type(res) == DataFrame
+        assert len(res) == 2
+        assert len(df.columns) == 1
+        assert "b" in df.columns
+        assert "a" not in df.columns
+        assert len(df.index) == 2
+
+    def test_mixed_depth_pop(self):
+        arrays = [
+            ["a", "top", "top", "routine1", "routine1", "routine2"],
+            ["", "OD", "OD", "result1", "result2", "result1"],
+            ["", "wx", "wy", "", "", ""],
+        ]
+
+        tuples = sorted(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples)
+        df = DataFrame(np.random.default_rng(2).standard_normal((4, 6)), columns=index)
+
+        df1 = df.copy()
+        df2 = df.copy()
+        result = df1.pop("a")
+        expected = df2.pop(("a", "", ""))
+        tm.assert_series_equal(expected, result, check_names=False)
+        tm.assert_frame_equal(df1, df2)
+        assert result.name == "a"
+
+        expected = df1["top"]
+        df1 = df1.drop(["top"], axis=1)
+        result = df2.pop("top")
+        tm.assert_frame_equal(expected, result)
+        tm.assert_frame_equal(df1, df2)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_quantile.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_quantile.py
new file mode 100644
index 0000000000000000000000000000000000000000..61b253b24a7ecc6dfe43008a484b8adfb49ec8ce
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_quantile.py
@@ -0,0 +1,981 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture(
+    params=[["linear", "single"], ["nearest", "table"]], ids=lambda x: "-".join(x)
+)
+def interp_method(request):
+    """(interpolation, method) arguments for quantile"""
+    return request.param
+
+
+class TestDataFrameQuantile:
+    @pytest.mark.parametrize(
+        "df,expected",
+        [
+            [
+                DataFrame(
+                    {
+                        0: Series(pd.arrays.SparseArray([1, 2])),
+                        1: Series(pd.arrays.SparseArray([3, 4])),
+                    }
+                ),
+                Series([1.5, 3.5], name=0.5),
+            ],
+            [
+                DataFrame(Series([0.0, None, 1.0, 2.0], dtype="Sparse[float]")),
+                Series([1.0], name=0.5),
+            ],
+        ],
+    )
+    def test_quantile_sparse(self, df, expected):
+        # GH#17198
+        # GH#24600
+        result = df.quantile()
+        expected = expected.astype("Sparse[float]")
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile(
+        self, datetime_frame, interp_method, using_array_manager, request
+    ):
+        interpolation, method = interp_method
+        df = datetime_frame
+        result = df.quantile(
+            0.1, axis=0, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series(
+            [np.percentile(df[col], 10) for col in df.columns],
+            index=df.columns,
+            name=0.1,
+        )
+        if interpolation == "linear":
+            # np.percentile values only comparable to linear interpolation
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.index, expected.index)
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    using_array_manager, reason="Name set incorrectly for arraymanager"
+                )
+            )
+            assert result.name == expected.name
+
+        result = df.quantile(
+            0.9, axis=1, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series(
+            [np.percentile(df.loc[date], 90) for date in df.index],
+            index=df.index,
+            name=0.9,
+        )
+        if interpolation == "linear":
+            # np.percentile values only comparable to linear interpolation
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.index, expected.index)
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    using_array_manager, reason="Name set incorrectly for arraymanager"
+                )
+            )
+            assert result.name == expected.name
+
+    def test_empty(self, interp_method):
+        interpolation, method = interp_method
+        q = DataFrame({"x": [], "y": []}).quantile(
+            0.1, axis=0, numeric_only=True, interpolation=interpolation, method=method
+        )
+        assert np.isnan(q["x"]) and np.isnan(q["y"])
+
+    def test_non_numeric_exclusion(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        df = DataFrame({"col1": ["A", "A", "B", "B"], "col2": [1, 2, 3, 4]})
+        rs = df.quantile(
+            0.5, numeric_only=True, interpolation=interpolation, method=method
+        )
+        xp = df.median(numeric_only=True).rename(0.5)
+        if interpolation == "nearest":
+            xp = (xp + 0.5).astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_series_equal(rs, xp)
+
+    def test_axis(self, interp_method, request, using_array_manager):
+        # axis
+        interpolation, method = interp_method
+        df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
+        result = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
+        expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_series_equal(result, expected)
+
+        result = df.quantile(
+            [0.5, 0.75], axis=1, interpolation=interpolation, method=method
+        )
+        expected = DataFrame(
+            {1: [1.5, 1.75], 2: [2.5, 2.75], 3: [3.5, 3.75]}, index=[0.5, 0.75]
+        )
+        if interpolation == "nearest":
+            expected.iloc[0, :] -= 0.5
+            expected.iloc[1, :] += 0.25
+            expected = expected.astype(np.int64)
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+    def test_axis_numeric_only_true(self, interp_method, request, using_array_manager):
+        # We may want to break API in the future to change this
+        # so that we exclude non-numeric along the same axis
+        # See GH #7312
+        interpolation, method = interp_method
+        df = DataFrame([[1, 2, 3], ["a", "b", 4]])
+        result = df.quantile(
+            0.5, axis=1, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series([3.0, 4.0], index=[0, 1], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_date_range(self, interp_method, request, using_array_manager):
+        # GH 2460
+        interpolation, method = interp_method
+        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+        ser = Series(dti)
+        df = DataFrame(ser)
+
+        result = df.quantile(
+            numeric_only=False, interpolation=interpolation, method=method
+        )
+        expected = Series(
+            ["2016-01-02 00:00:00"], name=0.5, dtype="datetime64[ns, US/Pacific]"
+        )
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_axis_mixed(self, interp_method, request, using_array_manager):
+        # mixed on axis=1
+        interpolation, method = interp_method
+        df = DataFrame(
+            {
+                "A": [1, 2, 3],
+                "B": [2.0, 3.0, 4.0],
+                "C": pd.date_range("20130101", periods=3),
+                "D": ["foo", "bar", "baz"],
+            }
+        )
+        result = df.quantile(
+            0.5, axis=1, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series([1.5, 2.5, 3.5], name=0.5)
+        if interpolation == "nearest":
+            expected -= 0.5
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_series_equal(result, expected)
+
+        # must raise
+        msg = "'<' not supported between instances of 'Timestamp' and 'float'"
+        with pytest.raises(TypeError, match=msg):
+            df.quantile(0.5, axis=1, numeric_only=False)
+
+    def test_quantile_axis_parameter(self, interp_method, request, using_array_manager):
+        # GH 9543/9544
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
+
+        result = df.quantile(0.5, axis=0, interpolation=interpolation, method=method)
+
+        expected = Series([2.0, 3.0], index=["A", "B"], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        tm.assert_series_equal(result, expected)
+
+        expected = df.quantile(
+            0.5, axis="index", interpolation=interpolation, method=method
+        )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        tm.assert_series_equal(result, expected)
+
+        result = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
+
+        expected = Series([1.5, 2.5, 3.5], index=[1, 2, 3], name=0.5)
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        tm.assert_series_equal(result, expected)
+
+        result = df.quantile(
+            0.5, axis="columns", interpolation=interpolation, method=method
+        )
+        tm.assert_series_equal(result, expected)
+
+        msg = "No axis named -1 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.quantile(0.1, axis=-1, interpolation=interpolation, method=method)
+        msg = "No axis named column for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.quantile(0.1, axis="column")
+
+    def test_quantile_interpolation(self):
+        # see gh-10174
+
+        # interpolation method other than default linear
+        df = DataFrame({"A": [1, 2, 3], "B": [2, 3, 4]}, index=[1, 2, 3])
+        result = df.quantile(0.5, axis=1, interpolation="nearest")
+        expected = Series([1, 2, 3], index=[1, 2, 3], name=0.5)
+        tm.assert_series_equal(result, expected)
+
+        # cross-check interpolation=nearest results in original dtype
+        exp = np.percentile(
+            np.array([[1, 2, 3], [2, 3, 4]]),
+            0.5,
+            axis=0,
+            method="nearest",
+        )
+        expected = Series(exp, index=[1, 2, 3], name=0.5, dtype="int64")
+        tm.assert_series_equal(result, expected)
+
+        # float
+        df = DataFrame({"A": [1.0, 2.0, 3.0], "B": [2.0, 3.0, 4.0]}, index=[1, 2, 3])
+        result = df.quantile(0.5, axis=1, interpolation="nearest")
+        expected = Series([1.0, 2.0, 3.0], index=[1, 2, 3], name=0.5)
+        tm.assert_series_equal(result, expected)
+        exp = np.percentile(
+            np.array([[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]]),
+            0.5,
+            axis=0,
+            method="nearest",
+        )
+        expected = Series(exp, index=[1, 2, 3], name=0.5, dtype="float64")
+        tm.assert_series_equal(result, expected)
+
+        # axis
+        result = df.quantile([0.5, 0.75], axis=1, interpolation="lower")
+        expected = DataFrame(
+            {1: [1.0, 1.0], 2: [2.0, 2.0], 3: [3.0, 3.0]}, index=[0.5, 0.75]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # test degenerate case
+        df = DataFrame({"x": [], "y": []})
+        q = df.quantile(0.1, axis=0, interpolation="higher")
+        assert np.isnan(q["x"]) and np.isnan(q["y"])
+
+        # multi
+        df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
+        result = df.quantile([0.25, 0.5], interpolation="midpoint")
+
+        # https://github.com/numpy/numpy/issues/7163
+        expected = DataFrame(
+            [[1.5, 1.5, 1.5], [2.0, 2.0, 2.0]],
+            index=[0.25, 0.5],
+            columns=["a", "b", "c"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_quantile_interpolation_datetime(self, datetime_frame):
+        # see gh-10174
+
+        # interpolation = linear (default case)
+        df = datetime_frame
+        q = df.quantile(0.1, axis=0, numeric_only=True, interpolation="linear")
+        assert q["A"] == np.percentile(df["A"], 10)
+
+    def test_quantile_interpolation_int(self, int_frame):
+        # see gh-10174
+
+        df = int_frame
+        # interpolation = linear (default case)
+        q = df.quantile(0.1)
+        assert q["A"] == np.percentile(df["A"], 10)
+
+        # test with and without interpolation keyword
+        q1 = df.quantile(0.1, axis=0, interpolation="linear")
+        assert q1["A"] == np.percentile(df["A"], 10)
+        tm.assert_series_equal(q, q1)
+
+    def test_quantile_multi(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
+        result = df.quantile([0.25, 0.5], interpolation=interpolation, method=method)
+        expected = DataFrame(
+            [[1.5, 1.5, 1.5], [2.0, 2.0, 2.0]],
+            index=[0.25, 0.5],
+            columns=["a", "b", "c"],
+        )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_frame_equal(result, expected)
+
+    def test_quantile_multi_axis_1(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        df = DataFrame([[1, 1, 1], [2, 2, 2], [3, 3, 3]], columns=["a", "b", "c"])
+        result = df.quantile(
+            [0.25, 0.5], axis=1, interpolation=interpolation, method=method
+        )
+        expected = DataFrame(
+            [[1.0, 2.0, 3.0]] * 2, index=[0.25, 0.5], columns=[0, 1, 2]
+        )
+        if interpolation == "nearest":
+            expected = expected.astype(np.int64)
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        tm.assert_frame_equal(result, expected)
+
+    def test_quantile_multi_empty(self, interp_method):
+        interpolation, method = interp_method
+        result = DataFrame({"x": [], "y": []}).quantile(
+            [0.1, 0.9], axis=0, interpolation=interpolation, method=method
+        )
+        expected = DataFrame(
+            {"x": [np.nan, np.nan], "y": [np.nan, np.nan]}, index=[0.1, 0.9]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_quantile_datetime(self):
+        df = DataFrame({"a": pd.to_datetime(["2010", "2011"]), "b": [0, 5]})
+
+        # exclude datetime
+        result = df.quantile(0.5, numeric_only=True)
+        expected = Series([2.5], index=["b"], name=0.5)
+        tm.assert_series_equal(result, expected)
+
+        # datetime
+        result = df.quantile(0.5, numeric_only=False)
+        expected = Series(
+            [Timestamp("2010-07-02 12:00:00"), 2.5], index=["a", "b"], name=0.5
+        )
+        tm.assert_series_equal(result, expected)
+
+        # datetime w/ multi
+        result = df.quantile([0.5], numeric_only=False)
+        expected = DataFrame(
+            [[Timestamp("2010-07-02 12:00:00"), 2.5]], index=[0.5], columns=["a", "b"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # axis = 1
+        df["c"] = pd.to_datetime(["2011", "2012"])
+        result = df[["a", "c"]].quantile(0.5, axis=1, numeric_only=False)
+        expected = Series(
+            [Timestamp("2010-07-02 12:00:00"), Timestamp("2011-07-02 12:00:00")],
+            index=[0, 1],
+            name=0.5,
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = df[["a", "c"]].quantile([0.5], axis=1, numeric_only=False)
+        expected = DataFrame(
+            [[Timestamp("2010-07-02 12:00:00"), Timestamp("2011-07-02 12:00:00")]],
+            index=[0.5],
+            columns=[0, 1],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # empty when numeric_only=True
+        result = df[["a", "c"]].quantile(0.5, numeric_only=True)
+        expected = Series([], index=[], dtype=np.float64, name=0.5)
+        tm.assert_series_equal(result, expected)
+
+        result = df[["a", "c"]].quantile([0.5], numeric_only=True)
+        expected = DataFrame(index=[0.5], columns=[])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "datetime64[ns]",
+            "datetime64[ns, US/Pacific]",
+            "timedelta64[ns]",
+            "Period[D]",
+        ],
+    )
+    def test_quantile_dt64_empty(self, dtype, interp_method):
+        # GH#41544
+        interpolation, method = interp_method
+        df = DataFrame(columns=["a", "b"], dtype=dtype)
+
+        res = df.quantile(
+            0.5, axis=1, numeric_only=False, interpolation=interpolation, method=method
+        )
+        expected = Series([], index=[], name=0.5, dtype=dtype)
+        tm.assert_series_equal(res, expected)
+
+        # no columns in result, so no dtype preservation
+        res = df.quantile(
+            [0.5],
+            axis=1,
+            numeric_only=False,
+            interpolation=interpolation,
+            method=method,
+        )
+        expected = DataFrame(index=[0.5], columns=[])
+        tm.assert_frame_equal(res, expected)
+
+    @pytest.mark.parametrize("invalid", [-1, 2, [0.5, -1], [0.5, 2]])
+    def test_quantile_invalid(self, invalid, datetime_frame, interp_method):
+        msg = "percentiles should all be in the interval \\[0, 1\\]"
+        interpolation, method = interp_method
+        with pytest.raises(ValueError, match=msg):
+            datetime_frame.quantile(invalid, interpolation=interpolation, method=method)
+
+    def test_quantile_box(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        df = DataFrame(
+            {
+                "A": [
+                    Timestamp("2011-01-01"),
+                    Timestamp("2011-01-02"),
+                    Timestamp("2011-01-03"),
+                ],
+                "B": [
+                    Timestamp("2011-01-01", tz="US/Eastern"),
+                    Timestamp("2011-01-02", tz="US/Eastern"),
+                    Timestamp("2011-01-03", tz="US/Eastern"),
+                ],
+                "C": [
+                    pd.Timedelta("1 days"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("3 days"),
+                ],
+            }
+        )
+
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
+
+        exp = Series(
+            [
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                pd.Timedelta("2 days"),
+            ],
+            name=0.5,
+            index=["A", "B", "C"],
+        )
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile(
+            [0.5], numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = DataFrame(
+            [
+                [
+                    Timestamp("2011-01-02"),
+                    Timestamp("2011-01-02", tz="US/Eastern"),
+                    pd.Timedelta("2 days"),
+                ]
+            ],
+            index=[0.5],
+            columns=["A", "B", "C"],
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_quantile_box_nat(self):
+        # DatetimeLikeBlock may be consolidated and contain NaT in different loc
+        df = DataFrame(
+            {
+                "A": [
+                    Timestamp("2011-01-01"),
+                    pd.NaT,
+                    Timestamp("2011-01-02"),
+                    Timestamp("2011-01-03"),
+                ],
+                "a": [
+                    Timestamp("2011-01-01"),
+                    Timestamp("2011-01-02"),
+                    pd.NaT,
+                    Timestamp("2011-01-03"),
+                ],
+                "B": [
+                    Timestamp("2011-01-01", tz="US/Eastern"),
+                    pd.NaT,
+                    Timestamp("2011-01-02", tz="US/Eastern"),
+                    Timestamp("2011-01-03", tz="US/Eastern"),
+                ],
+                "b": [
+                    Timestamp("2011-01-01", tz="US/Eastern"),
+                    Timestamp("2011-01-02", tz="US/Eastern"),
+                    pd.NaT,
+                    Timestamp("2011-01-03", tz="US/Eastern"),
+                ],
+                "C": [
+                    pd.Timedelta("1 days"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("3 days"),
+                    pd.NaT,
+                ],
+                "c": [
+                    pd.NaT,
+                    pd.Timedelta("1 days"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("3 days"),
+                ],
+            },
+            columns=list("AaBbCc"),
+        )
+
+        res = df.quantile(0.5, numeric_only=False)
+        exp = Series(
+            [
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                pd.Timedelta("2 days"),
+                pd.Timedelta("2 days"),
+            ],
+            name=0.5,
+            index=list("AaBbCc"),
+        )
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile([0.5], numeric_only=False)
+        exp = DataFrame(
+            [
+                [
+                    Timestamp("2011-01-02"),
+                    Timestamp("2011-01-02"),
+                    Timestamp("2011-01-02", tz="US/Eastern"),
+                    Timestamp("2011-01-02", tz="US/Eastern"),
+                    pd.Timedelta("2 days"),
+                    pd.Timedelta("2 days"),
+                ]
+            ],
+            index=[0.5],
+            columns=list("AaBbCc"),
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_quantile_nan(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        # GH 14357 - float block where some cols have missing values
+        df = DataFrame({"a": np.arange(1, 6.0), "b": np.arange(1, 6.0)})
+        df.iloc[-1, 1] = np.nan
+
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
+        exp = Series(
+            [3.0, 2.5 if interpolation == "linear" else 3.0], index=["a", "b"], name=0.5
+        )
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile([0.5, 0.75], interpolation=interpolation, method=method)
+        exp = DataFrame(
+            {
+                "a": [3.0, 4.0],
+                "b": [2.5, 3.25] if interpolation == "linear" else [3.0, 4.0],
+            },
+            index=[0.5, 0.75],
+        )
+        tm.assert_frame_equal(res, exp)
+
+        res = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
+        exp = Series(np.arange(1.0, 6.0), name=0.5)
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile(
+            [0.5, 0.75], axis=1, interpolation=interpolation, method=method
+        )
+        exp = DataFrame([np.arange(1.0, 6.0)] * 2, index=[0.5, 0.75])
+        if interpolation == "nearest":
+            exp.iloc[1, -1] = np.nan
+        tm.assert_frame_equal(res, exp)
+
+        # full-nan column
+        df["b"] = np.nan
+
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
+        exp = Series([3.0, np.nan], index=["a", "b"], name=0.5)
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile([0.5, 0.75], interpolation=interpolation, method=method)
+        exp = DataFrame({"a": [3.0, 4.0], "b": [np.nan, np.nan]}, index=[0.5, 0.75])
+        tm.assert_frame_equal(res, exp)
+
+    def test_quantile_nat(self, interp_method, request, using_array_manager):
+        interpolation, method = interp_method
+        if method == "table" and using_array_manager:
+            request.node.add_marker(
+                pytest.mark.xfail(reason="Axis name incorrectly set.")
+            )
+        # full NaT column
+        df = DataFrame({"a": [pd.NaT, pd.NaT, pd.NaT]})
+
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = Series([pd.NaT], index=["a"], name=0.5)
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile(
+            [0.5], numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = DataFrame({"a": [pd.NaT]}, index=[0.5])
+        tm.assert_frame_equal(res, exp)
+
+        # mixed non-null / full null column
+        df = DataFrame(
+            {
+                "a": [
+                    Timestamp("2012-01-01"),
+                    Timestamp("2012-01-02"),
+                    Timestamp("2012-01-03"),
+                ],
+                "b": [pd.NaT, pd.NaT, pd.NaT],
+            }
+        )
+
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = Series([Timestamp("2012-01-02"), pd.NaT], index=["a", "b"], name=0.5)
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile(
+            [0.5], numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = DataFrame(
+            [[Timestamp("2012-01-02"), pd.NaT]], index=[0.5], columns=["a", "b"]
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_quantile_empty_no_rows_floats(self, interp_method):
+        interpolation, method = interp_method
+
+        df = DataFrame(columns=["a", "b"], dtype="float64")
+
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
+        exp = Series([np.nan, np.nan], index=["a", "b"], name=0.5)
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile([0.5], interpolation=interpolation, method=method)
+        exp = DataFrame([[np.nan, np.nan]], columns=["a", "b"], index=[0.5])
+        tm.assert_frame_equal(res, exp)
+
+        res = df.quantile(0.5, axis=1, interpolation=interpolation, method=method)
+        exp = Series([], index=[], dtype="float64", name=0.5)
+        tm.assert_series_equal(res, exp)
+
+        res = df.quantile([0.5], axis=1, interpolation=interpolation, method=method)
+        exp = DataFrame(columns=[], index=[0.5])
+        tm.assert_frame_equal(res, exp)
+
+    def test_quantile_empty_no_rows_ints(self, interp_method):
+        interpolation, method = interp_method
+        df = DataFrame(columns=["a", "b"], dtype="int64")
+
+        res = df.quantile(0.5, interpolation=interpolation, method=method)
+        exp = Series([np.nan, np.nan], index=["a", "b"], name=0.5)
+        tm.assert_series_equal(res, exp)
+
+    def test_quantile_empty_no_rows_dt64(self, interp_method):
+        interpolation, method = interp_method
+        # datetimes
+        df = DataFrame(columns=["a", "b"], dtype="datetime64[ns]")
+
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = Series(
+            [pd.NaT, pd.NaT], index=["a", "b"], dtype="datetime64[ns]", name=0.5
+        )
+        tm.assert_series_equal(res, exp)
+
+        # Mixed dt64/dt64tz
+        df["a"] = df["a"].dt.tz_localize("US/Central")
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = exp.astype(object)
+        if interpolation == "nearest":
+            # GH#18463 TODO: would we prefer NaTs here?
+            msg = "The 'downcast' keyword in fillna is deprecated"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                exp = exp.fillna(np.nan, downcast=False)
+        tm.assert_series_equal(res, exp)
+
+        # both dt64tz
+        df["b"] = df["b"].dt.tz_localize("US/Central")
+        res = df.quantile(
+            0.5, numeric_only=False, interpolation=interpolation, method=method
+        )
+        exp = exp.astype(df["b"].dtype)
+        tm.assert_series_equal(res, exp)
+
+    def test_quantile_empty_no_columns(self, interp_method):
+        # GH#23925 _get_numeric_data may drop all columns
+        interpolation, method = interp_method
+        df = DataFrame(pd.date_range("1/1/18", periods=5))
+        df.columns.name = "captain tightpants"
+        result = df.quantile(
+            0.5, numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = Series([], index=[], name=0.5, dtype=np.float64)
+        expected.index.name = "captain tightpants"
+        tm.assert_series_equal(result, expected)
+
+        result = df.quantile(
+            [0.5], numeric_only=True, interpolation=interpolation, method=method
+        )
+        expected = DataFrame([], index=[0.5], columns=[])
+        expected.columns.name = "captain tightpants"
+        tm.assert_frame_equal(result, expected)
+
+    def test_quantile_item_cache(
+        self, using_array_manager, interp_method, using_copy_on_write
+    ):
+        # previous behavior incorrect retained an invalid _item_cache entry
+        interpolation, method = interp_method
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 3)), columns=["A", "B", "C"]
+        )
+        df["D"] = df["A"] * 2
+        ser = df["A"]
+        if not using_array_manager:
+            assert len(df._mgr.blocks) == 2
+
+        df.quantile(numeric_only=False, interpolation=interpolation, method=method)
+
+        if using_copy_on_write:
+            ser.iloc[0] = 99
+            assert df.iloc[0, 0] == df["A"][0]
+            assert df.iloc[0, 0] != 99
+        else:
+            ser.values[0] = 99
+            assert df.iloc[0, 0] == df["A"][0]
+            assert df.iloc[0, 0] == 99
+
+    def test_invalid_method(self):
+        with pytest.raises(ValueError, match="Invalid method: foo"):
+            DataFrame(range(1)).quantile(0.5, method="foo")
+
+    def test_table_invalid_interpolation(self):
+        with pytest.raises(ValueError, match="Invalid interpolation: foo"):
+            DataFrame(range(1)).quantile(0.5, method="table", interpolation="foo")
+
+
+class TestQuantileExtensionDtype:
+    # TODO: tests for axis=1?
+    # TODO: empty case?
+
+    @pytest.fixture(
+        params=[
+            pytest.param(
+                pd.IntervalIndex.from_breaks(range(10)),
+                marks=pytest.mark.xfail(reason="raises when trying to add Intervals"),
+            ),
+            pd.period_range("2016-01-01", periods=9, freq="D"),
+            pd.date_range("2016-01-01", periods=9, tz="US/Pacific"),
+            pd.timedelta_range("1 Day", periods=9),
+            pd.array(np.arange(9), dtype="Int64"),
+            pd.array(np.arange(9), dtype="Float64"),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def index(self, request):
+        # NB: not actually an Index object
+        idx = request.param
+        idx.name = "A"
+        return idx
+
+    @pytest.fixture
+    def obj(self, index, frame_or_series):
+        # bc index is not always an Index (yet), we need to re-patch .name
+        obj = frame_or_series(index).copy()
+
+        if frame_or_series is Series:
+            obj.name = "A"
+        else:
+            obj.columns = ["A"]
+        return obj
+
+    def compute_quantile(self, obj, qs):
+        if isinstance(obj, Series):
+            result = obj.quantile(qs)
+        else:
+            result = obj.quantile(qs, numeric_only=False)
+        return result
+
+    def test_quantile_ea(self, request, obj, index):
+        # result should be invariant to shuffling
+        indexer = np.arange(len(index), dtype=np.intp)
+        np.random.default_rng(2).shuffle(indexer)
+        obj = obj.iloc[indexer]
+
+        qs = [0.5, 0, 1]
+        result = self.compute_quantile(obj, qs)
+
+        exp_dtype = index.dtype
+        if index.dtype == "Int64":
+            # match non-nullable casting behavior
+            exp_dtype = "Float64"
+
+        # expected here assumes len(index) == 9
+        expected = Series(
+            [index[4], index[0], index[-1]], dtype=exp_dtype, index=qs, name="A"
+        )
+        expected = type(obj)(expected)
+
+        tm.assert_equal(result, expected)
+
+    def test_quantile_ea_with_na(self, obj, index):
+        obj.iloc[0] = index._na_value
+        obj.iloc[-1] = index._na_value
+
+        # result should be invariant to shuffling
+        indexer = np.arange(len(index), dtype=np.intp)
+        np.random.default_rng(2).shuffle(indexer)
+        obj = obj.iloc[indexer]
+
+        qs = [0.5, 0, 1]
+        result = self.compute_quantile(obj, qs)
+
+        # expected here assumes len(index) == 9
+        expected = Series(
+            [index[4], index[1], index[-2]], dtype=index.dtype, index=qs, name="A"
+        )
+        expected = type(obj)(expected)
+        tm.assert_equal(result, expected)
+
+    def test_quantile_ea_all_na(self, request, obj, index):
+        obj.iloc[:] = index._na_value
+        # Check dtypes were preserved; this was once a problem see GH#39763
+        assert np.all(obj.dtypes == index.dtype)
+
+        # result should be invariant to shuffling
+        indexer = np.arange(len(index), dtype=np.intp)
+        np.random.default_rng(2).shuffle(indexer)
+        obj = obj.iloc[indexer]
+
+        qs = [0.5, 0, 1]
+        result = self.compute_quantile(obj, qs)
+
+        expected = index.take([-1, -1, -1], allow_fill=True, fill_value=index._na_value)
+        expected = Series(expected, index=qs, name="A")
+        expected = type(obj)(expected)
+        tm.assert_equal(result, expected)
+
+    def test_quantile_ea_scalar(self, request, obj, index):
+        # scalar qs
+
+        # result should be invariant to shuffling
+        indexer = np.arange(len(index), dtype=np.intp)
+        np.random.default_rng(2).shuffle(indexer)
+        obj = obj.iloc[indexer]
+
+        qs = 0.5
+        result = self.compute_quantile(obj, qs)
+
+        exp_dtype = index.dtype
+        if index.dtype == "Int64":
+            exp_dtype = "Float64"
+
+        expected = Series({"A": index[4]}, dtype=exp_dtype, name=0.5)
+        if isinstance(obj, Series):
+            expected = expected["A"]
+            assert result == expected
+        else:
+            tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype, expected_data, expected_index, axis",
+        [
+            ["float64", [], [], 1],
+            ["int64", [], [], 1],
+            ["float64", [np.nan, np.nan], ["a", "b"], 0],
+            ["int64", [np.nan, np.nan], ["a", "b"], 0],
+        ],
+    )
+    def test_empty_numeric(self, dtype, expected_data, expected_index, axis):
+        # GH 14564
+        df = DataFrame(columns=["a", "b"], dtype=dtype)
+        result = df.quantile(0.5, axis=axis)
+        expected = Series(
+            expected_data, name=0.5, index=Index(expected_index), dtype="float64"
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype, expected_data, expected_index, axis, expected_dtype",
+        [
+            ["datetime64[ns]", [], [], 1, "datetime64[ns]"],
+            ["datetime64[ns]", [pd.NaT, pd.NaT], ["a", "b"], 0, "datetime64[ns]"],
+        ],
+    )
+    def test_empty_datelike(
+        self, dtype, expected_data, expected_index, axis, expected_dtype
+    ):
+        # GH 14564
+        df = DataFrame(columns=["a", "b"], dtype=dtype)
+        result = df.quantile(0.5, axis=axis, numeric_only=False)
+        expected = Series(
+            expected_data, name=0.5, index=Index(expected_index), dtype=expected_dtype
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "expected_data, expected_index, axis",
+        [
+            [[np.nan, np.nan], range(2), 1],
+            [[], [], 0],
+        ],
+    )
+    def test_datelike_numeric_only(self, expected_data, expected_index, axis):
+        # GH 14564
+        df = DataFrame(
+            {
+                "a": pd.to_datetime(["2010", "2011"]),
+                "b": [0, 5],
+                "c": pd.to_datetime(["2011", "2012"]),
+            }
+        )
+        result = df[["a", "c"]].quantile(0.5, axis=axis, numeric_only=True)
+        expected = Series(
+            expected_data, name=0.5, index=Index(expected_index), dtype=np.float64
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rank.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rank.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5b5e42691e59c0b63c8b31fb7a6d0fbab307c4c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rank.py
@@ -0,0 +1,502 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.algos import (
+    Infinity,
+    NegInfinity,
+)
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestRank:
+    s = Series([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])
+    df = DataFrame({"A": s, "B": s})
+
+    results = {
+        "average": np.array([1.5, 5.5, 7.0, 3.5, np.nan, 3.5, 1.5, 8.0, np.nan, 5.5]),
+        "min": np.array([1, 5, 7, 3, np.nan, 3, 1, 8, np.nan, 5]),
+        "max": np.array([2, 6, 7, 4, np.nan, 4, 2, 8, np.nan, 6]),
+        "first": np.array([1, 5, 7, 3, np.nan, 4, 2, 8, np.nan, 6]),
+        "dense": np.array([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3]),
+    }
+
+    @pytest.fixture(params=["average", "min", "max", "first", "dense"])
+    def method(self, request):
+        """
+        Fixture for trying all rank methods
+        """
+        return request.param
+
+    def test_rank(self, float_frame):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        float_frame.loc[::2, "A"] = np.nan
+        float_frame.loc[::3, "B"] = np.nan
+        float_frame.loc[::4, "C"] = np.nan
+        float_frame.loc[::5, "D"] = np.nan
+
+        ranks0 = float_frame.rank()
+        ranks1 = float_frame.rank(1)
+        mask = np.isnan(float_frame.values)
+
+        fvals = float_frame.fillna(np.inf).values
+
+        exp0 = np.apply_along_axis(sp_stats.rankdata, 0, fvals)
+        exp0[mask] = np.nan
+
+        exp1 = np.apply_along_axis(sp_stats.rankdata, 1, fvals)
+        exp1[mask] = np.nan
+
+        tm.assert_almost_equal(ranks0.values, exp0)
+        tm.assert_almost_equal(ranks1.values, exp1)
+
+        # integers
+        df = DataFrame(
+            np.random.default_rng(2).integers(0, 5, size=40).reshape((10, 4))
+        )
+
+        result = df.rank()
+        exp = df.astype(float).rank()
+        tm.assert_frame_equal(result, exp)
+
+        result = df.rank(1)
+        exp = df.astype(float).rank(1)
+        tm.assert_frame_equal(result, exp)
+
+    def test_rank2(self):
+        df = DataFrame([[1, 3, 2], [1, 2, 3]])
+        expected = DataFrame([[1.0, 3.0, 2.0], [1, 2, 3]]) / 3.0
+        result = df.rank(1, pct=True)
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame([[1, 3, 2], [1, 2, 3]])
+        expected = df.rank(0) / 2.0
+        result = df.rank(0, pct=True)
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame([["b", "c", "a"], ["a", "c", "b"]])
+        expected = DataFrame([[2.0, 3.0, 1.0], [1, 3, 2]])
+        result = df.rank(1, numeric_only=False)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame([[2.0, 1.5, 1.0], [1, 1.5, 2]])
+        result = df.rank(0, numeric_only=False)
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame([["b", np.nan, "a"], ["a", "c", "b"]])
+        expected = DataFrame([[2.0, np.nan, 1.0], [1.0, 3.0, 2.0]])
+        result = df.rank(1, numeric_only=False)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame([[2.0, np.nan, 1.0], [1.0, 1.0, 2.0]])
+        result = df.rank(0, numeric_only=False)
+        tm.assert_frame_equal(result, expected)
+
+        # f7u12, this does not work without extensive workaround
+        data = [
+            [datetime(2001, 1, 5), np.nan, datetime(2001, 1, 2)],
+            [datetime(2000, 1, 2), datetime(2000, 1, 3), datetime(2000, 1, 1)],
+        ]
+        df = DataFrame(data)
+
+        # check the rank
+        expected = DataFrame([[2.0, np.nan, 1.0], [2.0, 3.0, 1.0]])
+        result = df.rank(1, numeric_only=False, ascending=True)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame([[1.0, np.nan, 2.0], [2.0, 1.0, 3.0]])
+        result = df.rank(1, numeric_only=False, ascending=False)
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame({"a": [1e-20, -5, 1e-20 + 1e-40, 10, 1e60, 1e80, 1e-30]})
+        exp = DataFrame({"a": [3.5, 1.0, 3.5, 5.0, 6.0, 7.0, 2.0]})
+        tm.assert_frame_equal(df.rank(), exp)
+
+    def test_rank_does_not_mutate(self):
+        # GH#18521
+        # Check rank does not mutate DataFrame
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)), dtype="float64"
+        )
+        expected = df.copy()
+        df.rank()
+        result = df
+        tm.assert_frame_equal(result, expected)
+
+    def test_rank_mixed_frame(self, float_string_frame):
+        float_string_frame["datetime"] = datetime.now()
+        float_string_frame["timedelta"] = timedelta(days=1, seconds=1)
+
+        float_string_frame.rank(numeric_only=False)
+        with pytest.raises(TypeError, match="not supported between instances of"):
+            float_string_frame.rank(axis=1)
+
+    def test_rank_na_option(self, float_frame):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        float_frame.loc[::2, "A"] = np.nan
+        float_frame.loc[::3, "B"] = np.nan
+        float_frame.loc[::4, "C"] = np.nan
+        float_frame.loc[::5, "D"] = np.nan
+
+        # bottom
+        ranks0 = float_frame.rank(na_option="bottom")
+        ranks1 = float_frame.rank(1, na_option="bottom")
+
+        fvals = float_frame.fillna(np.inf).values
+
+        exp0 = np.apply_along_axis(sp_stats.rankdata, 0, fvals)
+        exp1 = np.apply_along_axis(sp_stats.rankdata, 1, fvals)
+
+        tm.assert_almost_equal(ranks0.values, exp0)
+        tm.assert_almost_equal(ranks1.values, exp1)
+
+        # top
+        ranks0 = float_frame.rank(na_option="top")
+        ranks1 = float_frame.rank(1, na_option="top")
+
+        fval0 = float_frame.fillna((float_frame.min() - 1).to_dict()).values
+        fval1 = float_frame.T
+        fval1 = fval1.fillna((fval1.min() - 1).to_dict()).T
+        fval1 = fval1.fillna(np.inf).values
+
+        exp0 = np.apply_along_axis(sp_stats.rankdata, 0, fval0)
+        exp1 = np.apply_along_axis(sp_stats.rankdata, 1, fval1)
+
+        tm.assert_almost_equal(ranks0.values, exp0)
+        tm.assert_almost_equal(ranks1.values, exp1)
+
+        # descending
+
+        # bottom
+        ranks0 = float_frame.rank(na_option="top", ascending=False)
+        ranks1 = float_frame.rank(1, na_option="top", ascending=False)
+
+        fvals = float_frame.fillna(np.inf).values
+
+        exp0 = np.apply_along_axis(sp_stats.rankdata, 0, -fvals)
+        exp1 = np.apply_along_axis(sp_stats.rankdata, 1, -fvals)
+
+        tm.assert_almost_equal(ranks0.values, exp0)
+        tm.assert_almost_equal(ranks1.values, exp1)
+
+        # descending
+
+        # top
+        ranks0 = float_frame.rank(na_option="bottom", ascending=False)
+        ranks1 = float_frame.rank(1, na_option="bottom", ascending=False)
+
+        fval0 = float_frame.fillna((float_frame.min() - 1).to_dict()).values
+        fval1 = float_frame.T
+        fval1 = fval1.fillna((fval1.min() - 1).to_dict()).T
+        fval1 = fval1.fillna(np.inf).values
+
+        exp0 = np.apply_along_axis(sp_stats.rankdata, 0, -fval0)
+        exp1 = np.apply_along_axis(sp_stats.rankdata, 1, -fval1)
+
+        tm.assert_numpy_array_equal(ranks0.values, exp0)
+        tm.assert_numpy_array_equal(ranks1.values, exp1)
+
+        # bad values throw error
+        msg = "na_option must be one of 'keep', 'top', or 'bottom'"
+
+        with pytest.raises(ValueError, match=msg):
+            float_frame.rank(na_option="bad", ascending=False)
+
+        # invalid type
+        with pytest.raises(ValueError, match=msg):
+            float_frame.rank(na_option=True, ascending=False)
+
+    def test_rank_axis(self):
+        # check if using axes' names gives the same result
+        df = DataFrame([[2, 1], [4, 3]])
+        tm.assert_frame_equal(df.rank(axis=0), df.rank(axis="index"))
+        tm.assert_frame_equal(df.rank(axis=1), df.rank(axis="columns"))
+
+    @pytest.mark.parametrize("ax", [0, 1])
+    @pytest.mark.parametrize("m", ["average", "min", "max", "first", "dense"])
+    def test_rank_methods_frame(self, ax, m):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        xs = np.random.default_rng(2).integers(0, 21, (100, 26))
+        xs = (xs - 10.0) / 10.0
+        cols = [chr(ord("z") - i) for i in range(xs.shape[1])]
+
+        for vals in [xs, xs + 1e6, xs * 1e-6]:
+            df = DataFrame(vals, columns=cols)
+
+            result = df.rank(axis=ax, method=m)
+            sprank = np.apply_along_axis(
+                sp_stats.rankdata, ax, vals, m if m != "first" else "ordinal"
+            )
+            sprank = sprank.astype(np.float64)
+            expected = DataFrame(sprank, columns=cols).astype("float64")
+            tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["O", "f8", "i8"])
+    def test_rank_descending(self, method, dtype):
+        if "i" in dtype:
+            df = self.df.dropna().astype(dtype)
+        else:
+            df = self.df.astype(dtype)
+
+        res = df.rank(ascending=False)
+        expected = (df.max() - df).rank()
+        tm.assert_frame_equal(res, expected)
+
+        expected = (df.max() - df).rank(method=method)
+
+        if dtype != "O":
+            res2 = df.rank(method=method, ascending=False, numeric_only=True)
+            tm.assert_frame_equal(res2, expected)
+
+        res3 = df.rank(method=method, ascending=False, numeric_only=False)
+        tm.assert_frame_equal(res3, expected)
+
+    @pytest.mark.parametrize("axis", [0, 1])
+    @pytest.mark.parametrize("dtype", [None, object])
+    def test_rank_2d_tie_methods(self, method, axis, dtype):
+        df = self.df
+
+        def _check2d(df, expected, method="average", axis=0):
+            exp_df = DataFrame({"A": expected, "B": expected})
+
+            if axis == 1:
+                df = df.T
+                exp_df = exp_df.T
+
+            result = df.rank(method=method, axis=axis)
+            tm.assert_frame_equal(result, exp_df)
+
+        frame = df if dtype is None else df.astype(dtype)
+        _check2d(frame, self.results[method], method=method, axis=axis)
+
+    @pytest.mark.parametrize(
+        "method,exp",
+        [
+            ("dense", [[1.0, 1.0, 1.0], [1.0, 0.5, 2.0 / 3], [1.0, 0.5, 1.0 / 3]]),
+            (
+                "min",
+                [
+                    [1.0 / 3, 1.0, 1.0],
+                    [1.0 / 3, 1.0 / 3, 2.0 / 3],
+                    [1.0 / 3, 1.0 / 3, 1.0 / 3],
+                ],
+            ),
+            (
+                "max",
+                [[1.0, 1.0, 1.0], [1.0, 2.0 / 3, 2.0 / 3], [1.0, 2.0 / 3, 1.0 / 3]],
+            ),
+            (
+                "average",
+                [[2.0 / 3, 1.0, 1.0], [2.0 / 3, 0.5, 2.0 / 3], [2.0 / 3, 0.5, 1.0 / 3]],
+            ),
+            (
+                "first",
+                [
+                    [1.0 / 3, 1.0, 1.0],
+                    [2.0 / 3, 1.0 / 3, 2.0 / 3],
+                    [3.0 / 3, 2.0 / 3, 1.0 / 3],
+                ],
+            ),
+        ],
+    )
+    def test_rank_pct_true(self, method, exp):
+        # see gh-15630.
+
+        df = DataFrame([[2012, 66, 3], [2012, 65, 2], [2012, 65, 1]])
+        result = df.rank(method=method, pct=True)
+
+        expected = DataFrame(exp)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.single_cpu
+    def test_pct_max_many_rows(self):
+        # GH 18271
+        df = DataFrame(
+            {"A": np.arange(2**24 + 1), "B": np.arange(2**24 + 1, 0, -1)}
+        )
+        result = df.rank(pct=True).max()
+        assert (result == 1).all()
+
+    @pytest.mark.parametrize(
+        "contents,dtype",
+        [
+            (
+                [
+                    -np.inf,
+                    -50,
+                    -1,
+                    -1e-20,
+                    -1e-25,
+                    -1e-50,
+                    0,
+                    1e-40,
+                    1e-20,
+                    1e-10,
+                    2,
+                    40,
+                    np.inf,
+                ],
+                "float64",
+            ),
+            (
+                [
+                    -np.inf,
+                    -50,
+                    -1,
+                    -1e-20,
+                    -1e-25,
+                    -1e-45,
+                    0,
+                    1e-40,
+                    1e-20,
+                    1e-10,
+                    2,
+                    40,
+                    np.inf,
+                ],
+                "float32",
+            ),
+            ([np.iinfo(np.uint8).min, 1, 2, 100, np.iinfo(np.uint8).max], "uint8"),
+            (
+                [
+                    np.iinfo(np.int64).min,
+                    -100,
+                    0,
+                    1,
+                    9999,
+                    100000,
+                    1e10,
+                    np.iinfo(np.int64).max,
+                ],
+                "int64",
+            ),
+            ([NegInfinity(), "1", "A", "BA", "Ba", "C", Infinity()], "object"),
+            (
+                [datetime(2001, 1, 1), datetime(2001, 1, 2), datetime(2001, 1, 5)],
+                "datetime64",
+            ),
+        ],
+    )
+    def test_rank_inf_and_nan(self, contents, dtype, frame_or_series):
+        dtype_na_map = {
+            "float64": np.nan,
+            "float32": np.nan,
+            "object": None,
+            "datetime64": np.datetime64("nat"),
+        }
+        # Insert nans at random positions if underlying dtype has missing
+        # value. Then adjust the expected order by adding nans accordingly
+        # This is for testing whether rank calculation is affected
+        # when values are interwined with nan values.
+        values = np.array(contents, dtype=dtype)
+        exp_order = np.array(range(len(values)), dtype="float64") + 1.0
+        if dtype in dtype_na_map:
+            na_value = dtype_na_map[dtype]
+            nan_indices = np.random.default_rng(2).choice(range(len(values)), 5)
+            values = np.insert(values, nan_indices, na_value)
+            exp_order = np.insert(exp_order, nan_indices, np.nan)
+
+        # Shuffle the testing array and expected results in the same way
+        random_order = np.random.default_rng(2).permutation(len(values))
+        obj = frame_or_series(values[random_order])
+        expected = frame_or_series(exp_order[random_order], dtype="float64")
+        result = obj.rank()
+        tm.assert_equal(result, expected)
+
+    def test_df_series_inf_nan_consistency(self):
+        # GH#32593
+        index = [5, 4, 3, 2, 1, 6, 7, 8, 9, 10]
+        col1 = [5, 4, 3, 5, 8, 5, 2, 1, 6, 6]
+        col2 = [5, 4, np.nan, 5, 8, 5, np.inf, np.nan, 6, -np.inf]
+        df = DataFrame(
+            data={
+                "col1": col1,
+                "col2": col2,
+            },
+            index=index,
+            dtype="f8",
+        )
+        df_result = df.rank()
+
+        series_result = df.copy()
+        series_result["col1"] = df["col1"].rank()
+        series_result["col2"] = df["col2"].rank()
+
+        tm.assert_frame_equal(df_result, series_result)
+
+    def test_rank_both_inf(self):
+        # GH#32593
+        df = DataFrame({"a": [-np.inf, 0, np.inf]})
+        expected = DataFrame({"a": [1.0, 2.0, 3.0]})
+        result = df.rank()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "na_option,ascending,expected",
+        [
+            ("top", True, [3.0, 1.0, 2.0]),
+            ("top", False, [2.0, 1.0, 3.0]),
+            ("bottom", True, [2.0, 3.0, 1.0]),
+            ("bottom", False, [1.0, 3.0, 2.0]),
+        ],
+    )
+    def test_rank_inf_nans_na_option(
+        self, frame_or_series, method, na_option, ascending, expected
+    ):
+        obj = frame_or_series([np.inf, np.nan, -np.inf])
+        result = obj.rank(method=method, na_option=na_option, ascending=ascending)
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "na_option,ascending,expected",
+        [
+            ("bottom", True, [1.0, 2.0, 4.0, 3.0]),
+            ("bottom", False, [1.0, 2.0, 4.0, 3.0]),
+            ("top", True, [2.0, 3.0, 1.0, 4.0]),
+            ("top", False, [2.0, 3.0, 1.0, 4.0]),
+        ],
+    )
+    def test_rank_object_first(self, frame_or_series, na_option, ascending, expected):
+        obj = frame_or_series(["foo", "foo", None, "foo"])
+        result = obj.rank(method="first", na_option=na_option, ascending=ascending)
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data,expected",
+        [
+            ({"a": [1, 2, "a"], "b": [4, 5, 6]}, DataFrame({"b": [1.0, 2.0, 3.0]})),
+            ({"a": [1, 2, "a"]}, DataFrame(index=range(3), columns=[])),
+        ],
+    )
+    def test_rank_mixed_axis_zero(self, data, expected):
+        df = DataFrame(data)
+        with pytest.raises(TypeError, match="'<' not supported between instances of"):
+            df.rank()
+        result = df.rank(numeric_only=True)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype, exp_dtype",
+        [("string[pyarrow]", "Int64"), ("string[pyarrow_numpy]", "float64")],
+    )
+    def test_rank_string_dtype(self, dtype, exp_dtype):
+        # GH#55362
+        pytest.importorskip("pyarrow")
+        obj = Series(["foo", "foo", None, "foo"], dtype=dtype)
+        result = obj.rank(method="first")
+        expected = Series([1, 2, None, 3], dtype=exp_dtype)
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reindex.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..678fec835aa825ffa3d795f6dff39027fa299d9c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reindex.py
@@ -0,0 +1,1315 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+import inspect
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs.timezones import dateutil_gettz as gettz
+from pandas.compat import (
+    IS64,
+    is_platform_windows,
+)
+from pandas.compat.numpy import np_version_gt2
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+from pandas.api.types import CategoricalDtype as CDT
+
+
+class TestReindexSetIndex:
+    # Tests that check both reindex and set_index
+
+    def test_dti_set_index_reindex_datetimeindex(self):
+        # GH#6631
+        df = DataFrame(np.random.default_rng(2).random(6))
+        idx1 = date_range("2011/01/01", periods=6, freq="M", tz="US/Eastern")
+        idx2 = date_range("2013", periods=6, freq="A", tz="Asia/Tokyo")
+
+        df = df.set_index(idx1)
+        tm.assert_index_equal(df.index, idx1)
+        df = df.reindex(idx2)
+        tm.assert_index_equal(df.index, idx2)
+
+    def test_dti_set_index_reindex_freq_with_tz(self):
+        # GH#11314 with tz
+        index = date_range(
+            datetime(2015, 10, 1), datetime(2015, 10, 1, 23), freq="H", tz="US/Eastern"
+        )
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((24, 1)),
+            columns=["a"],
+            index=index,
+        )
+        new_index = date_range(
+            datetime(2015, 10, 2), datetime(2015, 10, 2, 23), freq="H", tz="US/Eastern"
+        )
+
+        result = df.set_index(new_index)
+        assert result.index.freq == index.freq
+
+    def test_set_reset_index_intervalindex(self):
+        df = DataFrame({"A": range(10)})
+        ser = pd.cut(df.A, 5)
+        df["B"] = ser
+        df = df.set_index("B")
+
+        df = df.reset_index()
+
+    def test_setitem_reset_index_dtypes(self):
+        # GH 22060
+        df = DataFrame(columns=["a", "b", "c"]).astype(
+            {"a": "datetime64[ns]", "b": np.int64, "c": np.float64}
+        )
+        df1 = df.set_index(["a"])
+        df1["d"] = []
+        result = df1.reset_index()
+        expected = DataFrame(columns=["a", "b", "c", "d"], index=range(0)).astype(
+            {"a": "datetime64[ns]", "b": np.int64, "c": np.float64, "d": np.float64}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df2 = df.set_index(["a", "b"])
+        df2["d"] = []
+        result = df2.reset_index()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "timezone, year, month, day, hour",
+        [["America/Chicago", 2013, 11, 3, 1], ["America/Santiago", 2021, 4, 3, 23]],
+    )
+    def test_reindex_timestamp_with_fold(self, timezone, year, month, day, hour):
+        # see gh-40817
+        test_timezone = gettz(timezone)
+        transition_1 = pd.Timestamp(
+            year=year,
+            month=month,
+            day=day,
+            hour=hour,
+            minute=0,
+            fold=0,
+            tzinfo=test_timezone,
+        )
+        transition_2 = pd.Timestamp(
+            year=year,
+            month=month,
+            day=day,
+            hour=hour,
+            minute=0,
+            fold=1,
+            tzinfo=test_timezone,
+        )
+        df = (
+            DataFrame({"index": [transition_1, transition_2], "vals": ["a", "b"]})
+            .set_index("index")
+            .reindex(["1", "2"])
+        )
+        exp = DataFrame({"index": ["1", "2"], "vals": [np.nan, np.nan]}).set_index(
+            "index"
+        )
+        exp = exp.astype(object)
+        tm.assert_frame_equal(
+            df,
+            exp,
+        )
+
+
+class TestDataFrameSelectReindex:
+    # These are specific reindex-based tests; other indexing tests should go in
+    # test_indexing
+
+    @pytest.mark.xfail(
+        not IS64 or (is_platform_windows() and not np_version_gt2),
+        reason="Passes int32 values to DatetimeArray in make_na_array on "
+        "windows, 32bit linux builds",
+    )
+    @td.skip_array_manager_not_yet_implemented
+    def test_reindex_tzaware_fill_value(self):
+        # GH#52586
+        df = DataFrame([[1]])
+
+        ts = pd.Timestamp("2023-04-10 17:32", tz="US/Pacific")
+        res = df.reindex([0, 1], axis=1, fill_value=ts)
+        assert res.dtypes[1] == pd.DatetimeTZDtype(unit="s", tz="US/Pacific")
+        expected = DataFrame({0: [1], 1: [ts]})
+        expected[1] = expected[1].astype(res.dtypes[1])
+        tm.assert_frame_equal(res, expected)
+
+        per = ts.tz_localize(None).to_period("s")
+        res = df.reindex([0, 1], axis=1, fill_value=per)
+        assert res.dtypes[1] == pd.PeriodDtype("s")
+        expected = DataFrame({0: [1], 1: [per]})
+        tm.assert_frame_equal(res, expected)
+
+        interval = pd.Interval(ts, ts + pd.Timedelta(seconds=1))
+        res = df.reindex([0, 1], axis=1, fill_value=interval)
+        assert res.dtypes[1] == pd.IntervalDtype("datetime64[s, US/Pacific]", "right")
+        expected = DataFrame({0: [1], 1: [interval]})
+        expected[1] = expected[1].astype(res.dtypes[1])
+        tm.assert_frame_equal(res, expected)
+
+    def test_reindex_copies(self):
+        # based on asv time_reindex_axis1
+        N = 10
+        df = DataFrame(np.random.default_rng(2).standard_normal((N * 10, N)))
+        cols = np.arange(N)
+        np.random.default_rng(2).shuffle(cols)
+
+        result = df.reindex(columns=cols, copy=True)
+        assert not np.shares_memory(result[0]._values, df[0]._values)
+
+        # pass both columns and index
+        result2 = df.reindex(columns=cols, index=df.index, copy=True)
+        assert not np.shares_memory(result2[0]._values, df[0]._values)
+
+    def test_reindex_copies_ea(self, using_copy_on_write):
+        # https://github.com/pandas-dev/pandas/pull/51197
+        # also ensure to honor copy keyword for ExtensionDtypes
+        N = 10
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((N * 10, N)), dtype="Float64"
+        )
+        cols = np.arange(N)
+        np.random.default_rng(2).shuffle(cols)
+
+        result = df.reindex(columns=cols, copy=True)
+        if using_copy_on_write:
+            assert np.shares_memory(result[0].array._data, df[0].array._data)
+        else:
+            assert not np.shares_memory(result[0].array._data, df[0].array._data)
+
+        # pass both columns and index
+        result2 = df.reindex(columns=cols, index=df.index, copy=True)
+        if using_copy_on_write:
+            assert np.shares_memory(result2[0].array._data, df[0].array._data)
+        else:
+            assert not np.shares_memory(result2[0].array._data, df[0].array._data)
+
+    @td.skip_array_manager_not_yet_implemented
+    def test_reindex_date_fill_value(self):
+        # passing date to dt64 is deprecated; enforced in 2.0 to cast to object
+        arr = date_range("2016-01-01", periods=6).values.reshape(3, 2)
+        df = DataFrame(arr, columns=["A", "B"], index=range(3))
+
+        ts = df.iloc[0, 0]
+        fv = ts.date()
+
+        res = df.reindex(index=range(4), columns=["A", "B", "C"], fill_value=fv)
+
+        expected = DataFrame(
+            {"A": df["A"].tolist() + [fv], "B": df["B"].tolist() + [fv], "C": [fv] * 4},
+            dtype=object,
+        )
+        tm.assert_frame_equal(res, expected)
+
+        # only reindexing rows
+        res = df.reindex(index=range(4), fill_value=fv)
+        tm.assert_frame_equal(res, expected[["A", "B"]])
+
+        # same with a datetime-castable str
+        res = df.reindex(
+            index=range(4), columns=["A", "B", "C"], fill_value="2016-01-01"
+        )
+        expected = DataFrame(
+            {"A": df["A"].tolist() + [ts], "B": df["B"].tolist() + [ts], "C": [ts] * 4},
+        )
+        tm.assert_frame_equal(res, expected)
+
+    def test_reindex_with_multi_index(self):
+        # https://github.com/pandas-dev/pandas/issues/29896
+        # tests for reindexing a multi-indexed DataFrame with a new MultiIndex
+        #
+        # confirms that we can reindex a multi-indexed DataFrame with a new
+        # MultiIndex object correctly when using no filling, backfilling, and
+        # padding
+        #
+        # The DataFrame, `df`, used in this test is:
+        #       c
+        #  a b
+        # -1 0  A
+        #    1  B
+        #    2  C
+        #    3  D
+        #    4  E
+        #    5  F
+        #    6  G
+        #  0 0  A
+        #    1  B
+        #    2  C
+        #    3  D
+        #    4  E
+        #    5  F
+        #    6  G
+        #  1 0  A
+        #    1  B
+        #    2  C
+        #    3  D
+        #    4  E
+        #    5  F
+        #    6  G
+        #
+        # and the other MultiIndex, `new_multi_index`, is:
+        # 0: 0 0.5
+        # 1:   2.0
+        # 2:   5.0
+        # 3:   5.8
+        df = DataFrame(
+            {
+                "a": [-1] * 7 + [0] * 7 + [1] * 7,
+                "b": list(range(7)) * 3,
+                "c": ["A", "B", "C", "D", "E", "F", "G"] * 3,
+            }
+        ).set_index(["a", "b"])
+        new_index = [0.5, 2.0, 5.0, 5.8]
+        new_multi_index = MultiIndex.from_product([[0], new_index], names=["a", "b"])
+
+        # reindexing w/o a `method` value
+        reindexed = df.reindex(new_multi_index)
+        expected = DataFrame(
+            {"a": [0] * 4, "b": new_index, "c": [np.nan, "C", "F", np.nan]}
+        ).set_index(["a", "b"])
+        tm.assert_frame_equal(expected, reindexed)
+
+        # reindexing with backfilling
+        expected = DataFrame(
+            {"a": [0] * 4, "b": new_index, "c": ["B", "C", "F", "G"]}
+        ).set_index(["a", "b"])
+        reindexed_with_backfilling = df.reindex(new_multi_index, method="bfill")
+        tm.assert_frame_equal(expected, reindexed_with_backfilling)
+
+        reindexed_with_backfilling = df.reindex(new_multi_index, method="backfill")
+        tm.assert_frame_equal(expected, reindexed_with_backfilling)
+
+        # reindexing with padding
+        expected = DataFrame(
+            {"a": [0] * 4, "b": new_index, "c": ["A", "C", "F", "F"]}
+        ).set_index(["a", "b"])
+        reindexed_with_padding = df.reindex(new_multi_index, method="pad")
+        tm.assert_frame_equal(expected, reindexed_with_padding)
+
+        reindexed_with_padding = df.reindex(new_multi_index, method="ffill")
+        tm.assert_frame_equal(expected, reindexed_with_padding)
+
+    @pytest.mark.parametrize(
+        "method,expected_values",
+        [
+            ("nearest", [0, 1, 1, 2]),
+            ("pad", [np.nan, 0, 1, 1]),
+            ("backfill", [0, 1, 2, 2]),
+        ],
+    )
+    def test_reindex_methods(self, method, expected_values):
+        df = DataFrame({"x": list(range(5))})
+        target = np.array([-0.1, 0.9, 1.1, 1.5])
+
+        expected = DataFrame({"x": expected_values}, index=target)
+        actual = df.reindex(target, method=method)
+        tm.assert_frame_equal(expected, actual)
+
+        actual = df.reindex(target, method=method, tolerance=1)
+        tm.assert_frame_equal(expected, actual)
+        actual = df.reindex(target, method=method, tolerance=[1, 1, 1, 1])
+        tm.assert_frame_equal(expected, actual)
+
+        e2 = expected[::-1]
+        actual = df.reindex(target[::-1], method=method)
+        tm.assert_frame_equal(e2, actual)
+
+        new_order = [3, 0, 2, 1]
+        e2 = expected.iloc[new_order]
+        actual = df.reindex(target[new_order], method=method)
+        tm.assert_frame_equal(e2, actual)
+
+        switched_method = (
+            "pad" if method == "backfill" else "backfill" if method == "pad" else method
+        )
+        actual = df[::-1].reindex(target, method=switched_method)
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reindex_methods_nearest_special(self):
+        df = DataFrame({"x": list(range(5))})
+        target = np.array([-0.1, 0.9, 1.1, 1.5])
+
+        expected = DataFrame({"x": [0, 1, 1, np.nan]}, index=target)
+        actual = df.reindex(target, method="nearest", tolerance=0.2)
+        tm.assert_frame_equal(expected, actual)
+
+        expected = DataFrame({"x": [0, np.nan, 1, np.nan]}, index=target)
+        actual = df.reindex(target, method="nearest", tolerance=[0.5, 0.01, 0.4, 0.1])
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reindex_nearest_tz(self, tz_aware_fixture):
+        # GH26683
+        tz = tz_aware_fixture
+        idx = date_range("2019-01-01", periods=5, tz=tz)
+        df = DataFrame({"x": list(range(5))}, index=idx)
+
+        expected = df.head(3)
+        actual = df.reindex(idx[:3], method="nearest")
+        tm.assert_frame_equal(expected, actual)
+
+    def test_reindex_nearest_tz_empty_frame(self):
+        # https://github.com/pandas-dev/pandas/issues/31964
+        dti = pd.DatetimeIndex(["2016-06-26 14:27:26+00:00"])
+        df = DataFrame(index=pd.DatetimeIndex(["2016-07-04 14:00:59+00:00"]))
+        expected = DataFrame(index=dti)
+        result = df.reindex(dti, method="nearest")
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_frame_add_nat(self):
+        rng = date_range("1/1/2000 00:00:00", periods=10, freq="10s")
+        df = DataFrame(
+            {"A": np.random.default_rng(2).standard_normal(len(rng)), "B": rng}
+        )
+
+        result = df.reindex(range(15))
+        assert np.issubdtype(result["B"].dtype, np.dtype("M8[ns]"))
+
+        mask = isna(result)["B"]
+        assert mask[-5:].all()
+        assert not mask[:-5].any()
+
+    @pytest.mark.parametrize(
+        "method, exp_values",
+        [("ffill", [0, 1, 2, 3]), ("bfill", [1.0, 2.0, 3.0, np.nan])],
+    )
+    def test_reindex_frame_tz_ffill_bfill(self, frame_or_series, method, exp_values):
+        # GH#38566
+        obj = frame_or_series(
+            [0, 1, 2, 3],
+            index=date_range("2020-01-01 00:00:00", periods=4, freq="H", tz="UTC"),
+        )
+        new_index = date_range("2020-01-01 00:01:00", periods=4, freq="H", tz="UTC")
+        result = obj.reindex(new_index, method=method, tolerance=pd.Timedelta("1 hour"))
+        expected = frame_or_series(exp_values, index=new_index)
+        tm.assert_equal(result, expected)
+
+    def test_reindex_limit(self):
+        # GH 28631
+        data = [["A", "A", "A"], ["B", "B", "B"], ["C", "C", "C"], ["D", "D", "D"]]
+        exp_data = [
+            ["A", "A", "A"],
+            ["B", "B", "B"],
+            ["C", "C", "C"],
+            ["D", "D", "D"],
+            ["D", "D", "D"],
+            [np.nan, np.nan, np.nan],
+        ]
+        df = DataFrame(data)
+        result = df.reindex([0, 1, 2, 3, 4, 5], method="ffill", limit=1)
+        expected = DataFrame(exp_data)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "idx, check_index_type",
+        [
+            [["C", "B", "A"], True],
+            [["F", "C", "A", "D"], True],
+            [["A"], True],
+            [["A", "B", "C"], True],
+            [["C", "A", "B"], True],
+            [["C", "B"], True],
+            [["C", "A"], True],
+            [["A", "B"], True],
+            [["B", "A", "C"], True],
+            # reindex by these causes different MultiIndex levels
+            [["D", "F"], False],
+            [["A", "C", "B"], False],
+        ],
+    )
+    def test_reindex_level_verify_first_level(self, idx, check_index_type):
+        df = DataFrame(
+            {
+                "jim": list("B" * 4 + "A" * 2 + "C" * 3),
+                "joe": list("abcdeabcd")[::-1],
+                "jolie": [10, 20, 30] * 3,
+                "joline": np.random.default_rng(2).integers(0, 1000, 9),
+            }
+        )
+        icol = ["jim", "joe", "jolie"]
+
+        def f(val):
+            return np.nonzero((df["jim"] == val).to_numpy())[0]
+
+        i = np.concatenate(list(map(f, idx)))
+        left = df.set_index(icol).reindex(idx, level="jim")
+        right = df.iloc[i].set_index(icol)
+        tm.assert_frame_equal(left, right, check_index_type=check_index_type)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            ("mid",),
+            ("mid", "btm"),
+            ("mid", "btm", "top"),
+            ("mid",),
+            ("mid", "top"),
+            ("mid", "top", "btm"),
+            ("btm",),
+            ("btm", "mid"),
+            ("btm", "mid", "top"),
+            ("btm",),
+            ("btm", "top"),
+            ("btm", "top", "mid"),
+            ("top",),
+            ("top", "mid"),
+            ("top", "mid", "btm"),
+            ("top",),
+            ("top", "btm"),
+            ("top", "btm", "mid"),
+        ],
+    )
+    def test_reindex_level_verify_first_level_repeats(self, idx):
+        df = DataFrame(
+            {
+                "jim": ["mid"] * 5 + ["btm"] * 8 + ["top"] * 7,
+                "joe": ["3rd"] * 2
+                + ["1st"] * 3
+                + ["2nd"] * 3
+                + ["1st"] * 2
+                + ["3rd"] * 3
+                + ["1st"] * 2
+                + ["3rd"] * 3
+                + ["2nd"] * 2,
+                # this needs to be jointly unique with jim and joe or
+                # reindexing will fail ~1.5% of the time, this works
+                # out to needing unique groups of same size as joe
+                "jolie": np.concatenate(
+                    [
+                        np.random.default_rng(2).choice(1000, x, replace=False)
+                        for x in [2, 3, 3, 2, 3, 2, 3, 2]
+                    ]
+                ),
+                "joline": np.random.default_rng(2).standard_normal(20).round(3) * 10,
+            }
+        )
+        icol = ["jim", "joe", "jolie"]
+
+        def f(val):
+            return np.nonzero((df["jim"] == val).to_numpy())[0]
+
+        i = np.concatenate(list(map(f, idx)))
+        left = df.set_index(icol).reindex(idx, level="jim")
+        right = df.iloc[i].set_index(icol)
+        tm.assert_frame_equal(left, right)
+
+    @pytest.mark.parametrize(
+        "idx, indexer",
+        [
+            [
+                ["1st", "2nd", "3rd"],
+                [2, 3, 4, 0, 1, 8, 9, 5, 6, 7, 10, 11, 12, 13, 14, 18, 19, 15, 16, 17],
+            ],
+            [
+                ["3rd", "2nd", "1st"],
+                [0, 1, 2, 3, 4, 10, 11, 12, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 13, 14],
+            ],
+            [["2nd", "3rd"], [0, 1, 5, 6, 7, 10, 11, 12, 18, 19, 15, 16, 17]],
+            [["3rd", "1st"], [0, 1, 2, 3, 4, 10, 11, 12, 8, 9, 15, 16, 17, 13, 14]],
+        ],
+    )
+    def test_reindex_level_verify_repeats(self, idx, indexer):
+        df = DataFrame(
+            {
+                "jim": ["mid"] * 5 + ["btm"] * 8 + ["top"] * 7,
+                "joe": ["3rd"] * 2
+                + ["1st"] * 3
+                + ["2nd"] * 3
+                + ["1st"] * 2
+                + ["3rd"] * 3
+                + ["1st"] * 2
+                + ["3rd"] * 3
+                + ["2nd"] * 2,
+                # this needs to be jointly unique with jim and joe or
+                # reindexing will fail ~1.5% of the time, this works
+                # out to needing unique groups of same size as joe
+                "jolie": np.concatenate(
+                    [
+                        np.random.default_rng(2).choice(1000, x, replace=False)
+                        for x in [2, 3, 3, 2, 3, 2, 3, 2]
+                    ]
+                ),
+                "joline": np.random.default_rng(2).standard_normal(20).round(3) * 10,
+            }
+        )
+        icol = ["jim", "joe", "jolie"]
+        left = df.set_index(icol).reindex(idx, level="joe")
+        right = df.iloc[indexer].set_index(icol)
+        tm.assert_frame_equal(left, right)
+
+    @pytest.mark.parametrize(
+        "idx, indexer, check_index_type",
+        [
+            [list("abcde"), [3, 2, 1, 0, 5, 4, 8, 7, 6], True],
+            [list("abcd"), [3, 2, 1, 0, 5, 8, 7, 6], True],
+            [list("abc"), [3, 2, 1, 8, 7, 6], True],
+            [list("eca"), [1, 3, 4, 6, 8], True],
+            [list("edc"), [0, 1, 4, 5, 6], True],
+            [list("eadbc"), [3, 0, 2, 1, 4, 5, 8, 7, 6], True],
+            [list("edwq"), [0, 4, 5], True],
+            [list("wq"), [], False],
+        ],
+    )
+    def test_reindex_level_verify(self, idx, indexer, check_index_type):
+        df = DataFrame(
+            {
+                "jim": list("B" * 4 + "A" * 2 + "C" * 3),
+                "joe": list("abcdeabcd")[::-1],
+                "jolie": [10, 20, 30] * 3,
+                "joline": np.random.default_rng(2).integers(0, 1000, 9),
+            }
+        )
+        icol = ["jim", "joe", "jolie"]
+        left = df.set_index(icol).reindex(idx, level="joe")
+        right = df.iloc[indexer].set_index(icol)
+        tm.assert_frame_equal(left, right, check_index_type=check_index_type)
+
+    def test_non_monotonic_reindex_methods(self):
+        dr = date_range("2013-08-01", periods=6, freq="B")
+        data = np.random.default_rng(2).standard_normal((6, 1))
+        df = DataFrame(data, index=dr, columns=list("A"))
+        df_rev = DataFrame(data, index=dr[[3, 4, 5] + [0, 1, 2]], columns=list("A"))
+        # index is not monotonic increasing or decreasing
+        msg = "index must be monotonic increasing or decreasing"
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="pad")
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="ffill")
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="bfill")
+        with pytest.raises(ValueError, match=msg):
+            df_rev.reindex(df.index, method="nearest")
+
+    def test_reindex_sparse(self):
+        # https://github.com/pandas-dev/pandas/issues/35286
+        df = DataFrame(
+            {"A": [0, 1], "B": pd.array([0, 1], dtype=pd.SparseDtype("int64", 0))}
+        )
+        result = df.reindex([0, 2])
+        expected = DataFrame(
+            {
+                "A": [0.0, np.nan],
+                "B": pd.array([0.0, np.nan], dtype=pd.SparseDtype("float64", 0.0)),
+            },
+            index=[0, 2],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex(self, float_frame, using_copy_on_write):
+        datetime_series = tm.makeTimeSeries(nper=30)
+
+        newFrame = float_frame.reindex(datetime_series.index)
+
+        for col in newFrame.columns:
+            for idx, val in newFrame[col].items():
+                if idx in float_frame.index:
+                    if np.isnan(val):
+                        assert np.isnan(float_frame[col][idx])
+                    else:
+                        assert val == float_frame[col][idx]
+                else:
+                    assert np.isnan(val)
+
+        for col, series in newFrame.items():
+            assert tm.equalContents(series.index, newFrame.index)
+        emptyFrame = float_frame.reindex(Index([]))
+        assert len(emptyFrame.index) == 0
+
+        # Cython code should be unit-tested directly
+        nonContigFrame = float_frame.reindex(datetime_series.index[::2])
+
+        for col in nonContigFrame.columns:
+            for idx, val in nonContigFrame[col].items():
+                if idx in float_frame.index:
+                    if np.isnan(val):
+                        assert np.isnan(float_frame[col][idx])
+                    else:
+                        assert val == float_frame[col][idx]
+                else:
+                    assert np.isnan(val)
+
+        for col, series in nonContigFrame.items():
+            assert tm.equalContents(series.index, nonContigFrame.index)
+
+        # corner cases
+
+        # Same index, copies values but not index if copy=False
+        newFrame = float_frame.reindex(float_frame.index, copy=False)
+        if using_copy_on_write:
+            assert newFrame.index.is_(float_frame.index)
+        else:
+            assert newFrame.index is float_frame.index
+
+        # length zero
+        newFrame = float_frame.reindex([])
+        assert newFrame.empty
+        assert len(newFrame.columns) == len(float_frame.columns)
+
+        # length zero with columns reindexed with non-empty index
+        newFrame = float_frame.reindex([])
+        newFrame = newFrame.reindex(float_frame.index)
+        assert len(newFrame.index) == len(float_frame.index)
+        assert len(newFrame.columns) == len(float_frame.columns)
+
+        # pass non-Index
+        newFrame = float_frame.reindex(list(datetime_series.index))
+        expected = datetime_series.index._with_freq(None)
+        tm.assert_index_equal(newFrame.index, expected)
+
+        # copy with no axes
+        result = float_frame.reindex()
+        tm.assert_frame_equal(result, float_frame)
+        assert result is not float_frame
+
+    def test_reindex_nan(self):
+        df = DataFrame(
+            [[1, 2], [3, 5], [7, 11], [9, 23]],
+            index=[2, np.nan, 1, 5],
+            columns=["joe", "jim"],
+        )
+
+        i, j = [np.nan, 5, 5, np.nan, 1, 2, np.nan], [1, 3, 3, 1, 2, 0, 1]
+        tm.assert_frame_equal(df.reindex(i), df.iloc[j])
+
+        df.index = df.index.astype("object")
+        tm.assert_frame_equal(df.reindex(i), df.iloc[j], check_index_type=False)
+
+        # GH10388
+        df = DataFrame(
+            {
+                "other": ["a", "b", np.nan, "c"],
+                "date": ["2015-03-22", np.nan, "2012-01-08", np.nan],
+                "amount": [2, 3, 4, 5],
+            }
+        )
+
+        df["date"] = pd.to_datetime(df.date)
+        df["delta"] = (pd.to_datetime("2015-06-18") - df["date"]).shift(1)
+
+        left = df.set_index(["delta", "other", "date"]).reset_index()
+        right = df.reindex(columns=["delta", "other", "date", "amount"])
+        tm.assert_frame_equal(left, right)
+
+    def test_reindex_name_remains(self):
+        s = Series(np.random.default_rng(2).random(10))
+        df = DataFrame(s, index=np.arange(len(s)))
+        i = Series(np.arange(10), name="iname")
+
+        df = df.reindex(i)
+        assert df.index.name == "iname"
+
+        df = df.reindex(Index(np.arange(10), name="tmpname"))
+        assert df.index.name == "tmpname"
+
+        s = Series(np.random.default_rng(2).random(10))
+        df = DataFrame(s.T, index=np.arange(len(s)))
+        i = Series(np.arange(10), name="iname")
+        df = df.reindex(columns=i)
+        assert df.columns.name == "iname"
+
+    def test_reindex_int(self, int_frame):
+        smaller = int_frame.reindex(int_frame.index[::2])
+
+        assert smaller["A"].dtype == np.int64
+
+        bigger = smaller.reindex(int_frame.index)
+        assert bigger["A"].dtype == np.float64
+
+        smaller = int_frame.reindex(columns=["A", "B"])
+        assert smaller["A"].dtype == np.int64
+
+    def test_reindex_columns(self, float_frame):
+        new_frame = float_frame.reindex(columns=["A", "B", "E"])
+
+        tm.assert_series_equal(new_frame["B"], float_frame["B"])
+        assert np.isnan(new_frame["E"]).all()
+        assert "C" not in new_frame
+
+        # Length zero
+        new_frame = float_frame.reindex(columns=[])
+        assert new_frame.empty
+
+    def test_reindex_columns_method(self):
+        # GH 14992, reindexing over columns ignored method
+        df = DataFrame(
+            data=[[11, 12, 13], [21, 22, 23], [31, 32, 33]],
+            index=[1, 2, 4],
+            columns=[1, 2, 4],
+            dtype=float,
+        )
+
+        # default method
+        result = df.reindex(columns=range(6))
+        expected = DataFrame(
+            data=[
+                [np.nan, 11, 12, np.nan, 13, np.nan],
+                [np.nan, 21, 22, np.nan, 23, np.nan],
+                [np.nan, 31, 32, np.nan, 33, np.nan],
+            ],
+            index=[1, 2, 4],
+            columns=range(6),
+            dtype=float,
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # method='ffill'
+        result = df.reindex(columns=range(6), method="ffill")
+        expected = DataFrame(
+            data=[
+                [np.nan, 11, 12, 12, 13, 13],
+                [np.nan, 21, 22, 22, 23, 23],
+                [np.nan, 31, 32, 32, 33, 33],
+            ],
+            index=[1, 2, 4],
+            columns=range(6),
+            dtype=float,
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # method='bfill'
+        result = df.reindex(columns=range(6), method="bfill")
+        expected = DataFrame(
+            data=[
+                [11, 11, 12, 13, 13, np.nan],
+                [21, 21, 22, 23, 23, np.nan],
+                [31, 31, 32, 33, 33, np.nan],
+            ],
+            index=[1, 2, 4],
+            columns=range(6),
+            dtype=float,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_axes(self):
+        # GH 3317, reindexing by both axes loses freq of the index
+        df = DataFrame(
+            np.ones((3, 3)),
+            index=[datetime(2012, 1, 1), datetime(2012, 1, 2), datetime(2012, 1, 3)],
+            columns=["a", "b", "c"],
+        )
+        time_freq = date_range("2012-01-01", "2012-01-03", freq="d")
+        some_cols = ["a", "b"]
+
+        index_freq = df.reindex(index=time_freq).index.freq
+        both_freq = df.reindex(index=time_freq, columns=some_cols).index.freq
+        seq_freq = df.reindex(index=time_freq).reindex(columns=some_cols).index.freq
+        assert index_freq == both_freq
+        assert index_freq == seq_freq
+
+    def test_reindex_fill_value(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+
+        # axis=0
+        result = df.reindex(list(range(15)))
+        assert np.isnan(result.values[-5:]).all()
+
+        result = df.reindex(range(15), fill_value=0)
+        expected = df.reindex(range(15)).fillna(0)
+        tm.assert_frame_equal(result, expected)
+
+        # axis=1
+        result = df.reindex(columns=range(5), fill_value=0.0)
+        expected = df.copy()
+        expected[4] = 0.0
+        tm.assert_frame_equal(result, expected)
+
+        result = df.reindex(columns=range(5), fill_value=0)
+        expected = df.copy()
+        expected[4] = 0
+        tm.assert_frame_equal(result, expected)
+
+        result = df.reindex(columns=range(5), fill_value="foo")
+        expected = df.copy()
+        expected[4] = "foo"
+        tm.assert_frame_equal(result, expected)
+
+        # other dtypes
+        df["foo"] = "foo"
+        result = df.reindex(range(15), fill_value=0)
+        expected = df.reindex(range(15)).fillna(0)
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_uint_dtypes_fill_value(self, any_unsigned_int_numpy_dtype):
+        # GH#48184
+        df = DataFrame({"a": [1, 2], "b": [1, 2]}, dtype=any_unsigned_int_numpy_dtype)
+        result = df.reindex(columns=list("abcd"), index=[0, 1, 2, 3], fill_value=10)
+        expected = DataFrame(
+            {"a": [1, 2, 10, 10], "b": [1, 2, 10, 10], "c": 10, "d": 10},
+            dtype=any_unsigned_int_numpy_dtype,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_single_column_ea_index_and_columns(self, any_numeric_ea_dtype):
+        # GH#48190
+        df = DataFrame({"a": [1, 2]}, dtype=any_numeric_ea_dtype)
+        result = df.reindex(columns=list("ab"), index=[0, 1, 2], fill_value=10)
+        expected = DataFrame(
+            {"a": Series([1, 2, 10], dtype=any_numeric_ea_dtype), "b": 10}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_dups(self):
+        # GH4746, reindex on duplicate index error messages
+        arr = np.random.default_rng(2).standard_normal(10)
+        df = DataFrame(arr, index=[1, 2, 3, 4, 5, 1, 2, 3, 4, 5])
+
+        # set index is ok
+        result = df.copy()
+        result.index = list(range(len(df)))
+        expected = DataFrame(arr, index=list(range(len(df))))
+        tm.assert_frame_equal(result, expected)
+
+        # reindex fails
+        msg = "cannot reindex on an axis with duplicate labels"
+        with pytest.raises(ValueError, match=msg):
+            df.reindex(index=list(range(len(df))))
+
+    def test_reindex_with_duplicate_columns(self):
+        # reindex is invalid!
+        df = DataFrame(
+            [[1, 5, 7.0], [1, 5, 7.0], [1, 5, 7.0]], columns=["bar", "a", "a"]
+        )
+        msg = "cannot reindex on an axis with duplicate labels"
+        with pytest.raises(ValueError, match=msg):
+            df.reindex(columns=["bar"])
+        with pytest.raises(ValueError, match=msg):
+            df.reindex(columns=["bar", "foo"])
+
+    def test_reindex_axis_style(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        expected = DataFrame(
+            {"A": [1, 2, np.nan], "B": [4, 5, np.nan]}, index=[0, 1, 3]
+        )
+        result = df.reindex([0, 1, 3])
+        tm.assert_frame_equal(result, expected)
+
+        result = df.reindex([0, 1, 3], axis=0)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.reindex([0, 1, 3], axis="index")
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_positional_raises(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        # Enforced in 2.0
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        msg = r"reindex\(\) takes from 1 to 2 positional arguments but 3 were given"
+        with pytest.raises(TypeError, match=msg):
+            df.reindex([0, 1], ["A", "B", "C"])
+
+    def test_reindex_axis_style_raises(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex([0, 1], columns=["A"], axis=1)
+
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex([0, 1], columns=["A"], axis="index")
+
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex(index=[0, 1], axis="index")
+
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex(index=[0, 1], axis="columns")
+
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex(columns=[0, 1], axis="columns")
+
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex(index=[0, 1], columns=[0, 1], axis="columns")
+
+        with pytest.raises(TypeError, match="Cannot specify all"):
+            df.reindex(labels=[0, 1], index=[0], columns=["A"])
+
+        # Mixing styles
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex(index=[0, 1], axis="index")
+
+        with pytest.raises(TypeError, match="Cannot specify both 'axis'"):
+            df.reindex(index=[0, 1], axis="columns")
+
+        # Duplicates
+        with pytest.raises(TypeError, match="multiple values"):
+            df.reindex([0, 1], labels=[0, 1])
+
+    def test_reindex_single_named_indexer(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        df = DataFrame({"A": [1, 2, 3], "B": [1, 2, 3]})
+        result = df.reindex([0, 1], columns=["A"])
+        expected = DataFrame({"A": [1, 2]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_api_equivalence(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        # equivalence of the labels/axis and index/columns API's
+        df = DataFrame(
+            [[1, 2, 3], [3, 4, 5], [5, 6, 7]],
+            index=["a", "b", "c"],
+            columns=["d", "e", "f"],
+        )
+
+        res1 = df.reindex(["b", "a"])
+        res2 = df.reindex(index=["b", "a"])
+        res3 = df.reindex(labels=["b", "a"])
+        res4 = df.reindex(labels=["b", "a"], axis=0)
+        res5 = df.reindex(["b", "a"], axis=0)
+        for res in [res2, res3, res4, res5]:
+            tm.assert_frame_equal(res1, res)
+
+        res1 = df.reindex(columns=["e", "d"])
+        res2 = df.reindex(["e", "d"], axis=1)
+        res3 = df.reindex(labels=["e", "d"], axis=1)
+        for res in [res2, res3]:
+            tm.assert_frame_equal(res1, res)
+
+        res1 = df.reindex(index=["b", "a"], columns=["e", "d"])
+        res2 = df.reindex(columns=["e", "d"], index=["b", "a"])
+        res3 = df.reindex(labels=["b", "a"], axis=0).reindex(labels=["e", "d"], axis=1)
+        for res in [res2, res3]:
+            tm.assert_frame_equal(res1, res)
+
+    def test_reindex_boolean(self):
+        frame = DataFrame(
+            np.ones((10, 2), dtype=bool), index=np.arange(0, 20, 2), columns=[0, 2]
+        )
+
+        reindexed = frame.reindex(np.arange(10))
+        assert reindexed.values.dtype == np.object_
+        assert isna(reindexed[0][1])
+
+        reindexed = frame.reindex(columns=range(3))
+        assert reindexed.values.dtype == np.object_
+        assert isna(reindexed[1]).all()
+
+    def test_reindex_objects(self, float_string_frame):
+        reindexed = float_string_frame.reindex(columns=["foo", "A", "B"])
+        assert "foo" in reindexed
+
+        reindexed = float_string_frame.reindex(columns=["A", "B"])
+        assert "foo" not in reindexed
+
+    def test_reindex_corner(self, int_frame):
+        index = Index(["a", "b", "c"])
+        dm = DataFrame({}).reindex(index=[1, 2, 3])
+        reindexed = dm.reindex(columns=index)
+        tm.assert_index_equal(reindexed.columns, index)
+
+        # ints are weird
+        smaller = int_frame.reindex(columns=["A", "B", "E"])
+        assert smaller["E"].dtype == np.float64
+
+    def test_reindex_with_nans(self):
+        df = DataFrame(
+            [[1, 2], [3, 4], [np.nan, np.nan], [7, 8], [9, 10]],
+            columns=["a", "b"],
+            index=[100.0, 101.0, np.nan, 102.0, 103.0],
+        )
+
+        result = df.reindex(index=[101.0, 102.0, 103.0])
+        expected = df.iloc[[1, 3, 4]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.reindex(index=[103.0])
+        expected = df.iloc[[4]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.reindex(index=[101.0])
+        expected = df.iloc[[1]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_multi(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((3, 3)))
+
+        result = df.reindex(index=range(4), columns=range(4))
+        expected = df.reindex(list(range(4))).reindex(columns=range(4))
+
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(np.random.default_rng(2).integers(0, 10, (3, 3)))
+
+        result = df.reindex(index=range(4), columns=range(4))
+        expected = df.reindex(list(range(4))).reindex(columns=range(4))
+
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(np.random.default_rng(2).integers(0, 10, (3, 3)))
+
+        result = df.reindex(index=range(2), columns=range(2))
+        expected = df.reindex(range(2)).reindex(columns=range(2))
+
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((5, 3)) + 1j,
+            columns=["a", "b", "c"],
+        )
+
+        result = df.reindex(index=[0, 1], columns=["a", "b"])
+        expected = df.reindex([0, 1]).reindex(columns=["a", "b"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_multi_categorical_time(self):
+        # https://github.com/pandas-dev/pandas/issues/21390
+        midx = MultiIndex.from_product(
+            [
+                Categorical(["a", "b", "c"]),
+                Categorical(date_range("2012-01-01", periods=3, freq="H")),
+            ]
+        )
+        df = DataFrame({"a": range(len(midx))}, index=midx)
+        df2 = df.iloc[[0, 1, 2, 3, 4, 5, 6, 8]]
+
+        result = df2.reindex(midx)
+        expected = DataFrame({"a": [0, 1, 2, 3, 4, 5, 6, np.nan, 8]}, index=midx)
+        tm.assert_frame_equal(result, expected)
+
+    def test_reindex_with_categoricalindex(self):
+        df = DataFrame(
+            {
+                "A": np.arange(3, dtype="int64"),
+            },
+            index=CategoricalIndex(list("abc"), dtype=CDT(list("cabe")), name="B"),
+        )
+
+        # reindexing
+        # convert to a regular index
+        result = df.reindex(["a", "b", "e"])
+        expected = DataFrame({"A": [0, 1, np.nan], "B": Series(list("abe"))}).set_index(
+            "B"
+        )
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(["a", "b"])
+        expected = DataFrame({"A": [0, 1], "B": Series(list("ab"))}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(["e"])
+        expected = DataFrame({"A": [np.nan], "B": Series(["e"])}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(["d"])
+        expected = DataFrame({"A": [np.nan], "B": Series(["d"])}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        # since we are actually reindexing with a Categorical
+        # then return a Categorical
+        cats = list("cabe")
+
+        result = df.reindex(Categorical(["a", "e"], categories=cats))
+        expected = DataFrame(
+            {"A": [0, np.nan], "B": Series(list("ae")).astype(CDT(cats))}
+        ).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(Categorical(["a"], categories=cats))
+        expected = DataFrame(
+            {"A": [0], "B": Series(list("a")).astype(CDT(cats))}
+        ).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(["a", "b", "e"])
+        expected = DataFrame({"A": [0, 1, np.nan], "B": Series(list("abe"))}).set_index(
+            "B"
+        )
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(["a", "b"])
+        expected = DataFrame({"A": [0, 1], "B": Series(list("ab"))}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(["e"])
+        expected = DataFrame({"A": [np.nan], "B": Series(["e"])}).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        # give back the type of categorical that we received
+        result = df.reindex(Categorical(["a", "e"], categories=cats, ordered=True))
+        expected = DataFrame(
+            {"A": [0, np.nan], "B": Series(list("ae")).astype(CDT(cats, ordered=True))}
+        ).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        result = df.reindex(Categorical(["a", "d"], categories=["a", "d"]))
+        expected = DataFrame(
+            {"A": [0, np.nan], "B": Series(list("ad")).astype(CDT(["a", "d"]))}
+        ).set_index("B")
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+
+        df2 = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+            },
+            index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cabe")), name="B"),
+        )
+        # passed duplicate indexers are not allowed
+        msg = "cannot reindex on an axis with duplicate labels"
+        with pytest.raises(ValueError, match=msg):
+            df2.reindex(["a", "b"])
+
+        # args NotImplemented ATM
+        msg = r"argument {} is not implemented for CategoricalIndex\.reindex"
+        with pytest.raises(NotImplementedError, match=msg.format("method")):
+            df.reindex(["a"], method="ffill")
+        with pytest.raises(NotImplementedError, match=msg.format("level")):
+            df.reindex(["a"], level=1)
+        with pytest.raises(NotImplementedError, match=msg.format("limit")):
+            df.reindex(["a"], limit=2)
+
+    def test_reindex_signature(self):
+        sig = inspect.signature(DataFrame.reindex)
+        parameters = set(sig.parameters)
+        assert parameters == {
+            "self",
+            "labels",
+            "index",
+            "columns",
+            "axis",
+            "limit",
+            "copy",
+            "level",
+            "method",
+            "fill_value",
+            "tolerance",
+        }
+
+    def test_reindex_multiindex_ffill_added_rows(self):
+        # GH#23693
+        # reindex added rows with nan values even when fill method was specified
+        mi = MultiIndex.from_tuples([("a", "b"), ("d", "e")])
+        df = DataFrame([[0, 7], [3, 4]], index=mi, columns=["x", "y"])
+        mi2 = MultiIndex.from_tuples([("a", "b"), ("d", "e"), ("h", "i")])
+        result = df.reindex(mi2, axis=0, method="ffill")
+        expected = DataFrame([[0, 7], [3, 4], [3, 4]], index=mi2, columns=["x", "y"])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            {"method": "pad", "tolerance": timedelta(seconds=9)},
+            {"method": "backfill", "tolerance": timedelta(seconds=9)},
+            {"method": "nearest"},
+            {"method": None},
+        ],
+    )
+    def test_reindex_empty_frame(self, kwargs):
+        # GH#27315
+        idx = date_range(start="2020", freq="30s", periods=3)
+        df = DataFrame([], index=Index([], name="time"), columns=["a"])
+        result = df.reindex(idx, **kwargs)
+        expected = DataFrame({"a": [np.nan] * 3}, index=idx, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "src_idx",
+        [
+            Index([]),
+            CategoricalIndex([]),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "cat_idx",
+        [
+            # No duplicates
+            Index([]),
+            CategoricalIndex([]),
+            Index(["A", "B"]),
+            CategoricalIndex(["A", "B"]),
+            # Duplicates: GH#38906
+            Index(["A", "A"]),
+            CategoricalIndex(["A", "A"]),
+        ],
+    )
+    def test_reindex_empty(self, src_idx, cat_idx):
+        df = DataFrame(columns=src_idx, index=["K"], dtype="f8")
+
+        result = df.reindex(columns=cat_idx)
+        expected = DataFrame(index=["K"], columns=cat_idx, dtype="f8")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["m8[ns]", "M8[ns]"])
+    def test_reindex_datetimelike_to_object(self, dtype):
+        # GH#39755 dont cast dt64/td64 to ints
+        mi = MultiIndex.from_product([list("ABCDE"), range(2)])
+
+        dti = date_range("2016-01-01", periods=10)
+        fv = np.timedelta64("NaT", "ns")
+        if dtype == "m8[ns]":
+            dti = dti - dti[0]
+            fv = np.datetime64("NaT", "ns")
+
+        ser = Series(dti, index=mi)
+        ser[::3] = pd.NaT
+
+        df = ser.unstack()
+
+        index = df.index.append(Index([1]))
+        columns = df.columns.append(Index(["foo"]))
+
+        res = df.reindex(index=index, columns=columns, fill_value=fv)
+
+        expected = DataFrame(
+            {
+                0: df[0].tolist() + [fv],
+                1: df[1].tolist() + [fv],
+                "foo": np.array(["NaT"] * 6, dtype=fv.dtype),
+            },
+            index=index,
+        )
+        assert (res.dtypes[[0, 1]] == object).all()
+        assert res.iloc[0, 0] is pd.NaT
+        assert res.iloc[-1, 0] is fv
+        assert res.iloc[-1, 1] is fv
+        tm.assert_frame_equal(res, expected)
+
+    @pytest.mark.parametrize(
+        "index_df,index_res,index_exp",
+        [
+            (
+                CategoricalIndex([], categories=["A"]),
+                Index(["A"]),
+                Index(["A"]),
+            ),
+            (
+                CategoricalIndex([], categories=["A"]),
+                Index(["B"]),
+                Index(["B"]),
+            ),
+            (
+                CategoricalIndex([], categories=["A"]),
+                CategoricalIndex(["A"]),
+                CategoricalIndex(["A"]),
+            ),
+            (
+                CategoricalIndex([], categories=["A"]),
+                CategoricalIndex(["B"]),
+                CategoricalIndex(["B"]),
+            ),
+        ],
+    )
+    def test_reindex_not_category(self, index_df, index_res, index_exp):
+        # GH#28690
+        df = DataFrame(index=index_df)
+        result = df.reindex(index=index_res)
+        expected = DataFrame(index=index_exp)
+        tm.assert_frame_equal(result, expected)
+
+    def test_invalid_method(self):
+        df = DataFrame({"A": [1, np.nan, 2]})
+
+        msg = "Invalid fill method"
+        with pytest.raises(ValueError, match=msg):
+            df.reindex([1, 0, 2], method="asfreq")
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reindex_like.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reindex_like.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce68ec28eec3dd85461fcecfe506524040f64542
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reindex_like.py
@@ -0,0 +1,39 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestDataFrameReindexLike:
+    def test_reindex_like(self, float_frame):
+        other = float_frame.reindex(index=float_frame.index[:10], columns=["C", "B"])
+
+        tm.assert_frame_equal(other, float_frame.reindex_like(other))
+
+    @pytest.mark.parametrize(
+        "method,expected_values",
+        [
+            ("nearest", [0, 1, 1, 2]),
+            ("pad", [np.nan, 0, 1, 1]),
+            ("backfill", [0, 1, 2, 2]),
+        ],
+    )
+    def test_reindex_like_methods(self, method, expected_values):
+        df = DataFrame({"x": list(range(5))})
+
+        result = df.reindex_like(df, method=method, tolerance=0)
+        tm.assert_frame_equal(df, result)
+        result = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
+        tm.assert_frame_equal(df, result)
+
+    def test_reindex_like_subclass(self):
+        # https://github.com/pandas-dev/pandas/issues/31925
+        class MyDataFrame(DataFrame):
+            pass
+
+        expected = DataFrame()
+        df = MyDataFrame()
+        result = df.reindex_like(expected)
+
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rename.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rename.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb70e656814f9bf48fc1237d39898dfd746faff5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rename.py
@@ -0,0 +1,417 @@
+from collections import ChainMap
+import inspect
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    merge,
+)
+import pandas._testing as tm
+
+
+class TestRename:
+    def test_rename_signature(self):
+        sig = inspect.signature(DataFrame.rename)
+        parameters = set(sig.parameters)
+        assert parameters == {
+            "self",
+            "mapper",
+            "index",
+            "columns",
+            "axis",
+            "inplace",
+            "copy",
+            "level",
+            "errors",
+        }
+
+    def test_rename_mi(self, frame_or_series):
+        obj = frame_or_series(
+            [11, 21, 31],
+            index=MultiIndex.from_tuples([("A", x) for x in ["a", "B", "c"]]),
+        )
+        obj.rename(str.lower)
+
+    def test_rename(self, float_frame):
+        mapping = {"A": "a", "B": "b", "C": "c", "D": "d"}
+
+        renamed = float_frame.rename(columns=mapping)
+        renamed2 = float_frame.rename(columns=str.lower)
+
+        tm.assert_frame_equal(renamed, renamed2)
+        tm.assert_frame_equal(
+            renamed2.rename(columns=str.upper), float_frame, check_names=False
+        )
+
+        # index
+        data = {"A": {"foo": 0, "bar": 1}}
+
+        # gets sorted alphabetical
+        df = DataFrame(data)
+        renamed = df.rename(index={"foo": "bar", "bar": "foo"})
+        tm.assert_index_equal(renamed.index, Index(["foo", "bar"]))
+
+        renamed = df.rename(index=str.upper)
+        tm.assert_index_equal(renamed.index, Index(["BAR", "FOO"]))
+
+        # have to pass something
+        with pytest.raises(TypeError, match="must pass an index to rename"):
+            float_frame.rename()
+
+        # partial columns
+        renamed = float_frame.rename(columns={"C": "foo", "D": "bar"})
+        tm.assert_index_equal(renamed.columns, Index(["A", "B", "foo", "bar"]))
+
+        # other axis
+        renamed = float_frame.T.rename(index={"C": "foo", "D": "bar"})
+        tm.assert_index_equal(renamed.index, Index(["A", "B", "foo", "bar"]))
+
+        # index with name
+        index = Index(["foo", "bar"], name="name")
+        renamer = DataFrame(data, index=index)
+        renamed = renamer.rename(index={"foo": "bar", "bar": "foo"})
+        tm.assert_index_equal(renamed.index, Index(["bar", "foo"], name="name"))
+        assert renamed.index.name == renamer.index.name
+
+    @pytest.mark.parametrize(
+        "args,kwargs",
+        [
+            ((ChainMap({"A": "a"}, {"B": "b"}),), {"axis": "columns"}),
+            ((), {"columns": ChainMap({"A": "a"}, {"B": "b"})}),
+        ],
+    )
+    def test_rename_chainmap(self, args, kwargs):
+        # see gh-23859
+        colAData = range(1, 11)
+        colBdata = np.random.default_rng(2).standard_normal(10)
+
+        df = DataFrame({"A": colAData, "B": colBdata})
+        result = df.rename(*args, **kwargs)
+
+        expected = DataFrame({"a": colAData, "b": colBdata})
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_multiindex(self):
+        tuples_index = [("foo1", "bar1"), ("foo2", "bar2")]
+        tuples_columns = [("fizz1", "buzz1"), ("fizz2", "buzz2")]
+        index = MultiIndex.from_tuples(tuples_index, names=["foo", "bar"])
+        columns = MultiIndex.from_tuples(tuples_columns, names=["fizz", "buzz"])
+        df = DataFrame([(0, 0), (1, 1)], index=index, columns=columns)
+
+        #
+        # without specifying level -> across all levels
+
+        renamed = df.rename(
+            index={"foo1": "foo3", "bar2": "bar3"},
+            columns={"fizz1": "fizz3", "buzz2": "buzz3"},
+        )
+        new_index = MultiIndex.from_tuples(
+            [("foo3", "bar1"), ("foo2", "bar3")], names=["foo", "bar"]
+        )
+        new_columns = MultiIndex.from_tuples(
+            [("fizz3", "buzz1"), ("fizz2", "buzz3")], names=["fizz", "buzz"]
+        )
+        tm.assert_index_equal(renamed.index, new_index)
+        tm.assert_index_equal(renamed.columns, new_columns)
+        assert renamed.index.names == df.index.names
+        assert renamed.columns.names == df.columns.names
+
+        #
+        # with specifying a level (GH13766)
+
+        # dict
+        new_columns = MultiIndex.from_tuples(
+            [("fizz3", "buzz1"), ("fizz2", "buzz2")], names=["fizz", "buzz"]
+        )
+        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level=0)
+        tm.assert_index_equal(renamed.columns, new_columns)
+        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level="fizz")
+        tm.assert_index_equal(renamed.columns, new_columns)
+
+        new_columns = MultiIndex.from_tuples(
+            [("fizz1", "buzz1"), ("fizz2", "buzz3")], names=["fizz", "buzz"]
+        )
+        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level=1)
+        tm.assert_index_equal(renamed.columns, new_columns)
+        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level="buzz")
+        tm.assert_index_equal(renamed.columns, new_columns)
+
+        # function
+        func = str.upper
+        new_columns = MultiIndex.from_tuples(
+            [("FIZZ1", "buzz1"), ("FIZZ2", "buzz2")], names=["fizz", "buzz"]
+        )
+        renamed = df.rename(columns=func, level=0)
+        tm.assert_index_equal(renamed.columns, new_columns)
+        renamed = df.rename(columns=func, level="fizz")
+        tm.assert_index_equal(renamed.columns, new_columns)
+
+        new_columns = MultiIndex.from_tuples(
+            [("fizz1", "BUZZ1"), ("fizz2", "BUZZ2")], names=["fizz", "buzz"]
+        )
+        renamed = df.rename(columns=func, level=1)
+        tm.assert_index_equal(renamed.columns, new_columns)
+        renamed = df.rename(columns=func, level="buzz")
+        tm.assert_index_equal(renamed.columns, new_columns)
+
+        # index
+        new_index = MultiIndex.from_tuples(
+            [("foo3", "bar1"), ("foo2", "bar2")], names=["foo", "bar"]
+        )
+        renamed = df.rename(index={"foo1": "foo3", "bar2": "bar3"}, level=0)
+        tm.assert_index_equal(renamed.index, new_index)
+
+    def test_rename_nocopy(self, float_frame, using_copy_on_write):
+        renamed = float_frame.rename(columns={"C": "foo"}, copy=False)
+
+        assert np.shares_memory(renamed["foo"]._values, float_frame["C"]._values)
+
+        renamed.loc[:, "foo"] = 1.0
+        if using_copy_on_write:
+            assert not (float_frame["C"] == 1.0).all()
+        else:
+            assert (float_frame["C"] == 1.0).all()
+
+    def test_rename_inplace(self, float_frame):
+        float_frame.rename(columns={"C": "foo"})
+        assert "C" in float_frame
+        assert "foo" not in float_frame
+
+        c_values = float_frame["C"]
+        float_frame = float_frame.copy()
+        return_value = float_frame.rename(columns={"C": "foo"}, inplace=True)
+        assert return_value is None
+
+        assert "C" not in float_frame
+        assert "foo" in float_frame
+        # GH 44153
+        # Used to be id(float_frame["foo"]) != c_id, but flaky in the CI
+        assert float_frame["foo"] is not c_values
+
+    def test_rename_bug(self):
+        # GH 5344
+        # rename set ref_locs, and set_index was not resetting
+        df = DataFrame({0: ["foo", "bar"], 1: ["bah", "bas"], 2: [1, 2]})
+        df = df.rename(columns={0: "a"})
+        df = df.rename(columns={1: "b"})
+        df = df.set_index(["a", "b"])
+        df.columns = ["2001-01-01"]
+        expected = DataFrame(
+            [[1], [2]],
+            index=MultiIndex.from_tuples(
+                [("foo", "bah"), ("bar", "bas")], names=["a", "b"]
+            ),
+            columns=["2001-01-01"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_rename_bug2(self):
+        # GH 19497
+        # rename was changing Index to MultiIndex if Index contained tuples
+
+        df = DataFrame(data=np.arange(3), index=[(0, 0), (1, 1), (2, 2)], columns=["a"])
+        df = df.rename({(1, 1): (5, 4)}, axis="index")
+        expected = DataFrame(
+            data=np.arange(3), index=[(0, 0), (5, 4), (2, 2)], columns=["a"]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_rename_errors_raises(self):
+        df = DataFrame(columns=["A", "B", "C", "D"])
+        with pytest.raises(KeyError, match="'E'] not found in axis"):
+            df.rename(columns={"A": "a", "E": "e"}, errors="raise")
+
+    @pytest.mark.parametrize(
+        "mapper, errors, expected_columns",
+        [
+            ({"A": "a", "E": "e"}, "ignore", ["a", "B", "C", "D"]),
+            ({"A": "a"}, "raise", ["a", "B", "C", "D"]),
+            (str.lower, "raise", ["a", "b", "c", "d"]),
+        ],
+    )
+    def test_rename_errors(self, mapper, errors, expected_columns):
+        # GH 13473
+        # rename now works with errors parameter
+        df = DataFrame(columns=["A", "B", "C", "D"])
+        result = df.rename(columns=mapper, errors=errors)
+        expected = DataFrame(columns=expected_columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_objects(self, float_string_frame):
+        renamed = float_string_frame.rename(columns=str.upper)
+
+        assert "FOO" in renamed
+        assert "foo" not in renamed
+
+    def test_rename_axis_style(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        df = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["X", "Y"])
+        expected = DataFrame({"a": [1, 2], "b": [1, 2]}, index=["X", "Y"])
+
+        result = df.rename(str.lower, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename(str.lower, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename({"A": "a", "B": "b"}, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename({"A": "a", "B": "b"}, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+        # Index
+        expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["x", "y"])
+        result = df.rename(str.lower, axis=0)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename(str.lower, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename({"X": "x", "Y": "y"}, axis=0)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename({"X": "x", "Y": "y"}, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+        result = df.rename(mapper=str.lower, axis="index")
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_mapper_multi(self):
+        df = DataFrame({"A": ["a", "b"], "B": ["c", "d"], "C": [1, 2]}).set_index(
+            ["A", "B"]
+        )
+        result = df.rename(str.upper)
+        expected = df.rename(index=str.upper)
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_positional_named(self):
+        # https://github.com/pandas-dev/pandas/issues/12392
+        df = DataFrame({"a": [1, 2], "b": [1, 2]}, index=["X", "Y"])
+        result = df.rename(index=str.lower, columns=str.upper)
+        expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["x", "y"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_axis_style_raises(self):
+        # see gh-12392
+        df = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["0", "1"])
+
+        # Named target and axis
+        over_spec_msg = "Cannot specify both 'axis' and any of 'index' or 'columns'"
+        with pytest.raises(TypeError, match=over_spec_msg):
+            df.rename(index=str.lower, axis=1)
+
+        with pytest.raises(TypeError, match=over_spec_msg):
+            df.rename(index=str.lower, axis="columns")
+
+        with pytest.raises(TypeError, match=over_spec_msg):
+            df.rename(columns=str.lower, axis="columns")
+
+        with pytest.raises(TypeError, match=over_spec_msg):
+            df.rename(index=str.lower, axis=0)
+
+        # Multiple targets and axis
+        with pytest.raises(TypeError, match=over_spec_msg):
+            df.rename(str.lower, index=str.lower, axis="columns")
+
+        # Too many targets
+        over_spec_msg = "Cannot specify both 'mapper' and any of 'index' or 'columns'"
+        with pytest.raises(TypeError, match=over_spec_msg):
+            df.rename(str.lower, index=str.lower, columns=str.lower)
+
+        # Duplicates
+        with pytest.raises(TypeError, match="multiple values"):
+            df.rename(id, mapper=id)
+
+    def test_rename_positional_raises(self):
+        # GH 29136
+        df = DataFrame(columns=["A", "B"])
+        msg = r"rename\(\) takes from 1 to 2 positional arguments"
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, str.lower)
+
+    def test_rename_no_mappings_raises(self):
+        # GH 29136
+        df = DataFrame([[1]])
+        msg = "must pass an index to rename"
+        with pytest.raises(TypeError, match=msg):
+            df.rename()
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, index=None)
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, columns=None)
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename(None, columns=None, index=None)
+
+    def test_rename_mapper_and_positional_arguments_raises(self):
+        # GH 29136
+        df = DataFrame([[1]])
+        msg = "Cannot specify both 'mapper' and any of 'index' or 'columns'"
+        with pytest.raises(TypeError, match=msg):
+            df.rename({}, index={})
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename({}, columns={})
+
+        with pytest.raises(TypeError, match=msg):
+            df.rename({}, columns={}, index={})
+
+    def test_rename_with_duplicate_columns(self):
+        # GH#4403
+        df4 = DataFrame(
+            {"RT": [0.0454], "TClose": [22.02], "TExg": [0.0422]},
+            index=MultiIndex.from_tuples(
+                [(600809, 20130331)], names=["STK_ID", "RPT_Date"]
+            ),
+        )
+
+        df5 = DataFrame(
+            {
+                "RPT_Date": [20120930, 20121231, 20130331],
+                "STK_ID": [600809] * 3,
+                "STK_Name": ["饡驦", "饡驦", "饡驦"],
+                "TClose": [38.05, 41.66, 30.01],
+            },
+            index=MultiIndex.from_tuples(
+                [(600809, 20120930), (600809, 20121231), (600809, 20130331)],
+                names=["STK_ID", "RPT_Date"],
+            ),
+        )
+        # TODO: can we construct this without merge?
+        k = merge(df4, df5, how="inner", left_index=True, right_index=True)
+        result = k.rename(columns={"TClose_x": "TClose", "TClose_y": "QT_Close"})
+        str(result)
+        result.dtypes
+
+        expected = DataFrame(
+            [[0.0454, 22.02, 0.0422, 20130331, 600809, "饡驦", 30.01]],
+            columns=[
+                "RT",
+                "TClose",
+                "TExg",
+                "RPT_Date",
+                "STK_ID",
+                "STK_Name",
+                "QT_Close",
+            ],
+        ).set_index(["STK_ID", "RPT_Date"], drop=False)
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_boolean_index(self):
+        df = DataFrame(np.arange(15).reshape(3, 5), columns=[False, True, 2, 3, 4])
+        mapper = {0: "foo", 1: "bar", 2: "bah"}
+        res = df.rename(index=mapper)
+        exp = DataFrame(
+            np.arange(15).reshape(3, 5),
+            columns=[False, True, 2, 3, 4],
+            index=["foo", "bar", "bah"],
+        )
+        tm.assert_frame_equal(res, exp)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rename_axis.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rename_axis.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd4a77c6509b8de7eb767bb44238004399c159a4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_rename_axis.py
@@ -0,0 +1,111 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameRenameAxis:
+    def test_rename_axis_inplace(self, float_frame):
+        # GH#15704
+        expected = float_frame.rename_axis("foo")
+        result = float_frame.copy()
+        return_value = no_return = result.rename_axis("foo", inplace=True)
+        assert return_value is None
+
+        assert no_return is None
+        tm.assert_frame_equal(result, expected)
+
+        expected = float_frame.rename_axis("bar", axis=1)
+        result = float_frame.copy()
+        return_value = no_return = result.rename_axis("bar", axis=1, inplace=True)
+        assert return_value is None
+
+        assert no_return is None
+        tm.assert_frame_equal(result, expected)
+
+    def test_rename_axis_raises(self):
+        # GH#17833
+        df = DataFrame({"A": [1, 2], "B": [1, 2]})
+        with pytest.raises(ValueError, match="Use `.rename`"):
+            df.rename_axis(id, axis=0)
+
+        with pytest.raises(ValueError, match="Use `.rename`"):
+            df.rename_axis({0: 10, 1: 20}, axis=0)
+
+        with pytest.raises(ValueError, match="Use `.rename`"):
+            df.rename_axis(id, axis=1)
+
+        with pytest.raises(ValueError, match="Use `.rename`"):
+            df["A"].rename_axis(id)
+
+    def test_rename_axis_mapper(self):
+        # GH#19978
+        mi = MultiIndex.from_product([["a", "b", "c"], [1, 2]], names=["ll", "nn"])
+        df = DataFrame(
+            {"x": list(range(len(mi))), "y": [i * 10 for i in range(len(mi))]}, index=mi
+        )
+
+        # Test for rename of the Index object of columns
+        result = df.rename_axis("cols", axis=1)
+        tm.assert_index_equal(result.columns, Index(["x", "y"], name="cols"))
+
+        # Test for rename of the Index object of columns using dict
+        result = result.rename_axis(columns={"cols": "new"}, axis=1)
+        tm.assert_index_equal(result.columns, Index(["x", "y"], name="new"))
+
+        # Test for renaming index using dict
+        result = df.rename_axis(index={"ll": "foo"})
+        assert result.index.names == ["foo", "nn"]
+
+        # Test for renaming index using a function
+        result = df.rename_axis(index=str.upper, axis=0)
+        assert result.index.names == ["LL", "NN"]
+
+        # Test for renaming index providing complete list
+        result = df.rename_axis(index=["foo", "goo"])
+        assert result.index.names == ["foo", "goo"]
+
+        # Test for changing index and columns at same time
+        sdf = df.reset_index().set_index("nn").drop(columns=["ll", "y"])
+        result = sdf.rename_axis(index="foo", columns="meh")
+        assert result.index.name == "foo"
+        assert result.columns.name == "meh"
+
+        # Test different error cases
+        with pytest.raises(TypeError, match="Must pass"):
+            df.rename_axis(index="wrong")
+
+        with pytest.raises(ValueError, match="Length of names"):
+            df.rename_axis(index=["wrong"])
+
+        with pytest.raises(TypeError, match="bogus"):
+            df.rename_axis(bogus=None)
+
+    @pytest.mark.parametrize(
+        "kwargs, rename_index, rename_columns",
+        [
+            ({"mapper": None, "axis": 0}, True, False),
+            ({"mapper": None, "axis": 1}, False, True),
+            ({"index": None}, True, False),
+            ({"columns": None}, False, True),
+            ({"index": None, "columns": None}, True, True),
+            ({}, False, False),
+        ],
+    )
+    def test_rename_axis_none(self, kwargs, rename_index, rename_columns):
+        # GH 25034
+        index = Index(list("abc"), name="foo")
+        columns = Index(["col1", "col2"], name="bar")
+        data = np.arange(6).reshape(3, 2)
+        df = DataFrame(data, index, columns)
+
+        result = df.rename_axis(**kwargs)
+        expected_index = index.rename(None) if rename_index else index
+        expected_columns = columns.rename(None) if rename_columns else columns
+        expected = DataFrame(data, expected_index, expected_columns)
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reorder_levels.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reorder_levels.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d6b65daae4d513b3d3333856a57a2199cb79ed0
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reorder_levels.py
@@ -0,0 +1,74 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+import pandas._testing as tm
+
+
+class TestReorderLevels:
+    def test_reorder_levels(self, frame_or_series):
+        index = MultiIndex(
+            levels=[["bar"], ["one", "two", "three"], [0, 1]],
+            codes=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+            names=["L0", "L1", "L2"],
+        )
+        df = DataFrame({"A": np.arange(6), "B": np.arange(6)}, index=index)
+        obj = tm.get_obj(df, frame_or_series)
+
+        # no change, position
+        result = obj.reorder_levels([0, 1, 2])
+        tm.assert_equal(obj, result)
+
+        # no change, labels
+        result = obj.reorder_levels(["L0", "L1", "L2"])
+        tm.assert_equal(obj, result)
+
+        # rotate, position
+        result = obj.reorder_levels([1, 2, 0])
+        e_idx = MultiIndex(
+            levels=[["one", "two", "three"], [0, 1], ["bar"]],
+            codes=[[0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1], [0, 0, 0, 0, 0, 0]],
+            names=["L1", "L2", "L0"],
+        )
+        expected = DataFrame({"A": np.arange(6), "B": np.arange(6)}, index=e_idx)
+        expected = tm.get_obj(expected, frame_or_series)
+        tm.assert_equal(result, expected)
+
+        result = obj.reorder_levels([0, 0, 0])
+        e_idx = MultiIndex(
+            levels=[["bar"], ["bar"], ["bar"]],
+            codes=[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]],
+            names=["L0", "L0", "L0"],
+        )
+        expected = DataFrame({"A": np.arange(6), "B": np.arange(6)}, index=e_idx)
+        expected = tm.get_obj(expected, frame_or_series)
+        tm.assert_equal(result, expected)
+
+        result = obj.reorder_levels(["L0", "L0", "L0"])
+        tm.assert_equal(result, expected)
+
+    def test_reorder_levels_swaplevel_equivalence(
+        self, multiindex_year_month_day_dataframe_random_data
+    ):
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        result = ymd.reorder_levels(["month", "day", "year"])
+        expected = ymd.swaplevel(0, 1).swaplevel(1, 2)
+        tm.assert_frame_equal(result, expected)
+
+        result = ymd["A"].reorder_levels(["month", "day", "year"])
+        expected = ymd["A"].swaplevel(0, 1).swaplevel(1, 2)
+        tm.assert_series_equal(result, expected)
+
+        result = ymd.T.reorder_levels(["month", "day", "year"], axis=1)
+        expected = ymd.T.swaplevel(0, 1, axis=1).swaplevel(1, 2, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        with pytest.raises(TypeError, match="hierarchical axis"):
+            ymd.reorder_levels([1, 2], axis=1)
+
+        with pytest.raises(IndexError, match="Too many levels"):
+            ymd.index.reorder_levels([1, 2, 3])
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_replace.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_replace.py
new file mode 100644
index 0000000000000000000000000000000000000000..61e44b4e24c085727e77a32f0439061d583d1590
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_replace.py
@@ -0,0 +1,1601 @@
+from __future__ import annotations
+
+from datetime import datetime
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def mix_ab() -> dict[str, list[int | str]]:
+    return {"a": list(range(4)), "b": list("ab..")}
+
+
+@pytest.fixture
+def mix_abc() -> dict[str, list[float | str]]:
+    return {"a": list(range(4)), "b": list("ab.."), "c": ["a", "b", np.nan, "d"]}
+
+
+class TestDataFrameReplace:
+    def test_replace_inplace(self, datetime_frame, float_string_frame):
+        datetime_frame.loc[datetime_frame.index[:5], "A"] = np.nan
+        datetime_frame.loc[datetime_frame.index[-5:], "A"] = np.nan
+
+        tsframe = datetime_frame.copy()
+        return_value = tsframe.replace(np.nan, 0, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
+
+        # mixed type
+        mf = float_string_frame
+        mf.iloc[5:20, mf.columns.get_loc("foo")] = np.nan
+        mf.iloc[-10:, mf.columns.get_loc("A")] = np.nan
+
+        result = float_string_frame.replace(np.nan, 0)
+        expected = float_string_frame.fillna(value=0)
+        tm.assert_frame_equal(result, expected)
+
+        tsframe = datetime_frame.copy()
+        return_value = tsframe.replace([np.nan], [0], inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
+
+    @pytest.mark.parametrize(
+        "to_replace,values,expected",
+        [
+            # lists of regexes and values
+            # list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
+            (
+                [r"\s*\.\s*", r"e|f|g"],
+                [np.nan, "crap"],
+                {
+                    "a": ["a", "b", np.nan, np.nan],
+                    "b": ["crap"] * 3 + ["h"],
+                    "c": ["h", "crap", "l", "o"],
+                },
+            ),
+            # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
+            (
+                [r"\s*(\.)\s*", r"(e|f|g)"],
+                [r"\1\1", r"\1_crap"],
+                {
+                    "a": ["a", "b", "..", ".."],
+                    "b": ["e_crap", "f_crap", "g_crap", "h"],
+                    "c": ["h", "e_crap", "l", "o"],
+                },
+            ),
+            # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
+            # or vN)]
+            (
+                [r"\s*(\.)\s*", r"e"],
+                [r"\1\1", r"crap"],
+                {
+                    "a": ["a", "b", "..", ".."],
+                    "b": ["crap", "f", "g", "h"],
+                    "c": ["h", "crap", "l", "o"],
+                },
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("use_value_regex_args", [True, False])
+    def test_regex_replace_list_obj(
+        self, to_replace, values, expected, inplace, use_value_regex_args
+    ):
+        df = DataFrame({"a": list("ab.."), "b": list("efgh"), "c": list("helo")})
+
+        if use_value_regex_args:
+            result = df.replace(value=values, regex=to_replace, inplace=inplace)
+        else:
+            result = df.replace(to_replace, values, regex=True, inplace=inplace)
+
+        if inplace:
+            assert result is None
+            result = df
+
+        expected = DataFrame(expected)
+        tm.assert_frame_equal(result, expected)
+
+    def test_regex_replace_list_mixed(self, mix_ab):
+        # mixed frame to make sure this doesn't break things
+        dfmix = DataFrame(mix_ab)
+
+        # lists of regexes and values
+        # list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
+        to_replace_res = [r"\s*\.\s*", r"a"]
+        values = [np.nan, "crap"]
+        mix2 = {"a": list(range(4)), "b": list("ab.."), "c": list("halo")}
+        dfmix2 = DataFrame(mix2)
+        res = dfmix2.replace(to_replace_res, values, regex=True)
+        expec = DataFrame(
+            {
+                "a": mix2["a"],
+                "b": ["crap", "b", np.nan, np.nan],
+                "c": ["h", "crap", "l", "o"],
+            }
+        )
+        tm.assert_frame_equal(res, expec)
+
+        # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
+        to_replace_res = [r"\s*(\.)\s*", r"(a|b)"]
+        values = [r"\1\1", r"\1_crap"]
+        res = dfmix.replace(to_replace_res, values, regex=True)
+        expec = DataFrame({"a": mix_ab["a"], "b": ["a_crap", "b_crap", "..", ".."]})
+        tm.assert_frame_equal(res, expec)
+
+        # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
+        # or vN)]
+        to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
+        values = [r"\1\1", r"crap", r"\1_crap"]
+        res = dfmix.replace(to_replace_res, values, regex=True)
+        expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
+        tm.assert_frame_equal(res, expec)
+
+        to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
+        values = [r"\1\1", r"crap", r"\1_crap"]
+        res = dfmix.replace(regex=to_replace_res, value=values)
+        expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
+        tm.assert_frame_equal(res, expec)
+
+    def test_regex_replace_list_mixed_inplace(self, mix_ab):
+        dfmix = DataFrame(mix_ab)
+        # the same inplace
+        # lists of regexes and values
+        # list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
+        to_replace_res = [r"\s*\.\s*", r"a"]
+        values = [np.nan, "crap"]
+        res = dfmix.copy()
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
+        expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b", np.nan, np.nan]})
+        tm.assert_frame_equal(res, expec)
+
+        # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
+        to_replace_res = [r"\s*(\.)\s*", r"(a|b)"]
+        values = [r"\1\1", r"\1_crap"]
+        res = dfmix.copy()
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
+        expec = DataFrame({"a": mix_ab["a"], "b": ["a_crap", "b_crap", "..", ".."]})
+        tm.assert_frame_equal(res, expec)
+
+        # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
+        # or vN)]
+        to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
+        values = [r"\1\1", r"crap", r"\1_crap"]
+        res = dfmix.copy()
+        return_value = res.replace(to_replace_res, values, inplace=True, regex=True)
+        assert return_value is None
+        expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
+        tm.assert_frame_equal(res, expec)
+
+        to_replace_res = [r"\s*(\.)\s*", r"a", r"(b)"]
+        values = [r"\1\1", r"crap", r"\1_crap"]
+        res = dfmix.copy()
+        return_value = res.replace(regex=to_replace_res, value=values, inplace=True)
+        assert return_value is None
+        expec = DataFrame({"a": mix_ab["a"], "b": ["crap", "b_crap", "..", ".."]})
+        tm.assert_frame_equal(res, expec)
+
+    def test_regex_replace_dict_mixed(self, mix_abc):
+        dfmix = DataFrame(mix_abc)
+
+        # dicts
+        # single dict {re1: v1}, search the whole frame
+        # need test for this...
+
+        # list of dicts {re1: v1, re2: v2, ..., re3: v3}, search the whole
+        # frame
+        res = dfmix.replace({"b": r"\s*\.\s*"}, {"b": np.nan}, regex=True)
+        res2 = dfmix.copy()
+        return_value = res2.replace(
+            {"b": r"\s*\.\s*"}, {"b": np.nan}, inplace=True, regex=True
+        )
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+
+        # list of dicts {re1: re11, re2: re12, ..., reN: re1N}, search the
+        # whole frame
+        res = dfmix.replace({"b": r"\s*(\.)\s*"}, {"b": r"\1ty"}, regex=True)
+        res2 = dfmix.copy()
+        return_value = res2.replace(
+            {"b": r"\s*(\.)\s*"}, {"b": r"\1ty"}, inplace=True, regex=True
+        )
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": ["a", "b", ".ty", ".ty"], "c": mix_abc["c"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+
+        res = dfmix.replace(regex={"b": r"\s*(\.)\s*"}, value={"b": r"\1ty"})
+        res2 = dfmix.copy()
+        return_value = res2.replace(
+            regex={"b": r"\s*(\.)\s*"}, value={"b": r"\1ty"}, inplace=True
+        )
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": ["a", "b", ".ty", ".ty"], "c": mix_abc["c"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+
+        # scalar -> dict
+        # to_replace regex, {value: value}
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": [np.nan, "b", ".", "."], "c": mix_abc["c"]}
+        )
+        res = dfmix.replace("a", {"b": np.nan}, regex=True)
+        res2 = dfmix.copy()
+        return_value = res2.replace("a", {"b": np.nan}, regex=True, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+
+        res = dfmix.replace("a", {"b": np.nan}, regex=True)
+        res2 = dfmix.copy()
+        return_value = res2.replace(regex="a", value={"b": np.nan}, inplace=True)
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": [np.nan, "b", ".", "."], "c": mix_abc["c"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+
+    def test_regex_replace_dict_nested(self, mix_abc):
+        # nested dicts will not work until this is implemented for Series
+        dfmix = DataFrame(mix_abc)
+        res = dfmix.replace({"b": {r"\s*\.\s*": np.nan}}, regex=True)
+        res2 = dfmix.copy()
+        res4 = dfmix.copy()
+        return_value = res2.replace(
+            {"b": {r"\s*\.\s*": np.nan}}, inplace=True, regex=True
+        )
+        assert return_value is None
+        res3 = dfmix.replace(regex={"b": {r"\s*\.\s*": np.nan}})
+        return_value = res4.replace(regex={"b": {r"\s*\.\s*": np.nan}}, inplace=True)
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
+        tm.assert_frame_equal(res4, expec)
+
+    def test_regex_replace_dict_nested_non_first_character(self, any_string_dtype):
+        # GH 25259
+        dtype = any_string_dtype
+        df = DataFrame({"first": ["abc", "bca", "cab"]}, dtype=dtype)
+        expected = DataFrame({"first": [".bc", "bc.", "c.b"]}, dtype=dtype)
+        result = df.replace({"a": "."}, regex=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_regex_replace_dict_nested_gh4115(self):
+        df = DataFrame({"Type": ["Q", "T", "Q", "Q", "T"], "tmp": 2})
+        expected = DataFrame({"Type": [0, 1, 0, 0, 1], "tmp": 2})
+        result = df.replace({"Type": {"Q": 0, "T": 1}})
+        tm.assert_frame_equal(result, expected)
+
+    def test_regex_replace_list_to_scalar(self, mix_abc):
+        df = DataFrame(mix_abc)
+        expec = DataFrame(
+            {
+                "a": mix_abc["a"],
+                "b": np.array([np.nan] * 4),
+                "c": [np.nan, np.nan, np.nan, "d"],
+            }
+        )
+        res = df.replace([r"\s*\.\s*", "a|b"], np.nan, regex=True)
+        res2 = df.copy()
+        res3 = df.copy()
+        return_value = res2.replace(
+            [r"\s*\.\s*", "a|b"], np.nan, regex=True, inplace=True
+        )
+        assert return_value is None
+        return_value = res3.replace(
+            regex=[r"\s*\.\s*", "a|b"], value=np.nan, inplace=True
+        )
+        assert return_value is None
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
+
+    def test_regex_replace_str_to_numeric(self, mix_abc):
+        # what happens when you try to replace a numeric value with a regex?
+        df = DataFrame(mix_abc)
+        res = df.replace(r"\s*\.\s*", 0, regex=True)
+        res2 = df.copy()
+        return_value = res2.replace(r"\s*\.\s*", 0, inplace=True, regex=True)
+        assert return_value is None
+        res3 = df.copy()
+        return_value = res3.replace(regex=r"\s*\.\s*", value=0, inplace=True)
+        assert return_value is None
+        expec = DataFrame({"a": mix_abc["a"], "b": ["a", "b", 0, 0], "c": mix_abc["c"]})
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
+
+    def test_regex_replace_regex_list_to_numeric(self, mix_abc):
+        df = DataFrame(mix_abc)
+        res = df.replace([r"\s*\.\s*", "b"], 0, regex=True)
+        res2 = df.copy()
+        return_value = res2.replace([r"\s*\.\s*", "b"], 0, regex=True, inplace=True)
+        assert return_value is None
+        res3 = df.copy()
+        return_value = res3.replace(regex=[r"\s*\.\s*", "b"], value=0, inplace=True)
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": ["a", 0, 0, 0], "c": ["a", 0, np.nan, "d"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
+
+    def test_regex_replace_series_of_regexes(self, mix_abc):
+        df = DataFrame(mix_abc)
+        s1 = Series({"b": r"\s*\.\s*"})
+        s2 = Series({"b": np.nan})
+        res = df.replace(s1, s2, regex=True)
+        res2 = df.copy()
+        return_value = res2.replace(s1, s2, inplace=True, regex=True)
+        assert return_value is None
+        res3 = df.copy()
+        return_value = res3.replace(regex=s1, value=s2, inplace=True)
+        assert return_value is None
+        expec = DataFrame(
+            {"a": mix_abc["a"], "b": ["a", "b", np.nan, np.nan], "c": mix_abc["c"]}
+        )
+        tm.assert_frame_equal(res, expec)
+        tm.assert_frame_equal(res2, expec)
+        tm.assert_frame_equal(res3, expec)
+
+    def test_regex_replace_numeric_to_object_conversion(self, mix_abc):
+        df = DataFrame(mix_abc)
+        expec = DataFrame({"a": ["a", 1, 2, 3], "b": mix_abc["b"], "c": mix_abc["c"]})
+        res = df.replace(0, "a")
+        tm.assert_frame_equal(res, expec)
+        assert res.a.dtype == np.object_
+
+    @pytest.mark.parametrize(
+        "to_replace", [{"": np.nan, ",": ""}, {",": "", "": np.nan}]
+    )
+    def test_joint_simple_replace_and_regex_replace(self, to_replace):
+        # GH-39338
+        df = DataFrame(
+            {
+                "col1": ["1,000", "a", "3"],
+                "col2": ["a", "", "b"],
+                "col3": ["a", "b", "c"],
+            }
+        )
+        result = df.replace(regex=to_replace)
+        expected = DataFrame(
+            {
+                "col1": ["1000", "a", "3"],
+                "col2": ["a", np.nan, "b"],
+                "col3": ["a", "b", "c"],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("metachar", ["[]", "()", r"\d", r"\w", r"\s"])
+    def test_replace_regex_metachar(self, metachar):
+        df = DataFrame({"a": [metachar, "else"]})
+        result = df.replace({"a": {metachar: "paren"}})
+        expected = DataFrame({"a": ["paren", "else"]})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data,to_replace,expected",
+        [
+            (["xax", "xbx"], {"a": "c", "b": "d"}, ["xcx", "xdx"]),
+            (["d", "", ""], {r"^\s*$": pd.NA}, ["d", pd.NA, pd.NA]),
+        ],
+    )
+    def test_regex_replace_string_types(
+        self, data, to_replace, expected, frame_or_series, any_string_dtype
+    ):
+        # GH-41333, GH-35977
+        dtype = any_string_dtype
+        obj = frame_or_series(data, dtype=dtype)
+        result = obj.replace(to_replace, regex=True)
+        expected = frame_or_series(expected, dtype=dtype)
+
+        tm.assert_equal(result, expected)
+
+    def test_replace(self, datetime_frame):
+        datetime_frame.loc[datetime_frame.index[:5], "A"] = np.nan
+        datetime_frame.loc[datetime_frame.index[-5:], "A"] = np.nan
+
+        zero_filled = datetime_frame.replace(np.nan, -1e8)
+        tm.assert_frame_equal(zero_filled, datetime_frame.fillna(-1e8))
+        tm.assert_frame_equal(zero_filled.replace(-1e8, np.nan), datetime_frame)
+
+        datetime_frame.loc[datetime_frame.index[:5], "A"] = np.nan
+        datetime_frame.loc[datetime_frame.index[-5:], "A"] = np.nan
+        datetime_frame.loc[datetime_frame.index[:5], "B"] = -1e8
+
+        # empty
+        df = DataFrame(index=["a", "b"])
+        tm.assert_frame_equal(df, df.replace(5, 7))
+
+        # GH 11698
+        # test for mixed data types.
+        df = DataFrame(
+            [("-", pd.to_datetime("20150101")), ("a", pd.to_datetime("20150102"))]
+        )
+        df1 = df.replace("-", np.nan)
+        expected_df = DataFrame(
+            [(np.nan, pd.to_datetime("20150101")), ("a", pd.to_datetime("20150102"))]
+        )
+        tm.assert_frame_equal(df1, expected_df)
+
+    def test_replace_list(self):
+        obj = {"a": list("ab.."), "b": list("efgh"), "c": list("helo")}
+        dfobj = DataFrame(obj)
+
+        # lists of regexes and values
+        # list of [v1, v2, ..., vN] -> [v1, v2, ..., vN]
+        to_replace_res = [r".", r"e"]
+        values = [np.nan, "crap"]
+        res = dfobj.replace(to_replace_res, values)
+        expec = DataFrame(
+            {
+                "a": ["a", "b", np.nan, np.nan],
+                "b": ["crap", "f", "g", "h"],
+                "c": ["h", "crap", "l", "o"],
+            }
+        )
+        tm.assert_frame_equal(res, expec)
+
+        # list of [v1, v2, ..., vN] -> [v1, v2, .., vN]
+        to_replace_res = [r".", r"f"]
+        values = [r"..", r"crap"]
+        res = dfobj.replace(to_replace_res, values)
+        expec = DataFrame(
+            {
+                "a": ["a", "b", "..", ".."],
+                "b": ["e", "crap", "g", "h"],
+                "c": ["h", "e", "l", "o"],
+            }
+        )
+        tm.assert_frame_equal(res, expec)
+
+    def test_replace_with_empty_list(self, frame_or_series):
+        # GH 21977
+        ser = Series([["a", "b"], [], np.nan, [1]])
+        obj = DataFrame({"col": ser})
+        obj = tm.get_obj(obj, frame_or_series)
+        expected = obj
+        result = obj.replace([], np.nan)
+        tm.assert_equal(result, expected)
+
+        # GH 19266
+        msg = (
+            "NumPy boolean array indexing assignment cannot assign {size} "
+            "input values to the 1 output values where the mask is true"
+        )
+        with pytest.raises(ValueError, match=msg.format(size=0)):
+            obj.replace({np.nan: []})
+        with pytest.raises(ValueError, match=msg.format(size=2)):
+            obj.replace({np.nan: ["dummy", "alt"]})
+
+    def test_replace_series_dict(self):
+        # from GH 3064
+        df = DataFrame({"zero": {"a": 0.0, "b": 1}, "one": {"a": 2.0, "b": 0}})
+        result = df.replace(0, {"zero": 0.5, "one": 1.0})
+        expected = DataFrame({"zero": {"a": 0.5, "b": 1}, "one": {"a": 2.0, "b": 1.0}})
+        tm.assert_frame_equal(result, expected)
+
+        result = df.replace(0, df.mean())
+        tm.assert_frame_equal(result, expected)
+
+        # series to series/dict
+        df = DataFrame({"zero": {"a": 0.0, "b": 1}, "one": {"a": 2.0, "b": 0}})
+        s = Series({"zero": 0.0, "one": 2.0})
+        result = df.replace(s, {"zero": 0.5, "one": 1.0})
+        expected = DataFrame({"zero": {"a": 0.5, "b": 1}, "one": {"a": 1.0, "b": 0.0}})
+        tm.assert_frame_equal(result, expected)
+
+        result = df.replace(s, df.mean())
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_convert(self):
+        # gh 3907
+        df = DataFrame([["foo", "bar", "bah"], ["bar", "foo", "bah"]])
+        m = {"foo": 1, "bar": 2, "bah": 3}
+        rep = df.replace(m)
+        expec = Series([np.int64] * 3)
+        res = rep.dtypes
+        tm.assert_series_equal(expec, res)
+
+    def test_replace_mixed(self, float_string_frame):
+        mf = float_string_frame
+        mf.iloc[5:20, mf.columns.get_loc("foo")] = np.nan
+        mf.iloc[-10:, mf.columns.get_loc("A")] = np.nan
+
+        result = float_string_frame.replace(np.nan, -18)
+        expected = float_string_frame.fillna(value=-18)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result.replace(-18, np.nan), float_string_frame)
+
+        result = float_string_frame.replace(np.nan, -1e8)
+        expected = float_string_frame.fillna(value=-1e8)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result.replace(-1e8, np.nan), float_string_frame)
+
+    def test_replace_mixed_int_block_upcasting(self):
+        # int block upcasting
+        df = DataFrame(
+            {
+                "A": Series([1.0, 2.0], dtype="float64"),
+                "B": Series([0, 1], dtype="int64"),
+            }
+        )
+        expected = DataFrame(
+            {
+                "A": Series([1.0, 2.0], dtype="float64"),
+                "B": Series([0.5, 1], dtype="float64"),
+            }
+        )
+        result = df.replace(0, 0.5)
+        tm.assert_frame_equal(result, expected)
+
+        return_value = df.replace(0, 0.5, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(df, expected)
+
+    def test_replace_mixed_int_block_splitting(self):
+        # int block splitting
+        df = DataFrame(
+            {
+                "A": Series([1.0, 2.0], dtype="float64"),
+                "B": Series([0, 1], dtype="int64"),
+                "C": Series([1, 2], dtype="int64"),
+            }
+        )
+        expected = DataFrame(
+            {
+                "A": Series([1.0, 2.0], dtype="float64"),
+                "B": Series([0.5, 1], dtype="float64"),
+                "C": Series([1, 2], dtype="int64"),
+            }
+        )
+        result = df.replace(0, 0.5)
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_mixed2(self):
+        # to object block upcasting
+        df = DataFrame(
+            {
+                "A": Series([1.0, 2.0], dtype="float64"),
+                "B": Series([0, 1], dtype="int64"),
+            }
+        )
+        expected = DataFrame(
+            {
+                "A": Series([1, "foo"], dtype="object"),
+                "B": Series([0, 1], dtype="int64"),
+            }
+        )
+        result = df.replace(2, "foo")
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame(
+            {
+                "A": Series(["foo", "bar"], dtype="object"),
+                "B": Series([0, "foo"], dtype="object"),
+            }
+        )
+        result = df.replace([1, 2], ["foo", "bar"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_mixed3(self):
+        # test case from
+        df = DataFrame(
+            {"A": Series([3, 0], dtype="int64"), "B": Series([0, 3], dtype="int64")}
+        )
+        result = df.replace(3, df.mean().to_dict())
+        expected = df.copy().astype("float64")
+        m = df.mean()
+        expected.iloc[0, 0] = m.iloc[0]
+        expected.iloc[1, 1] = m.iloc[1]
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_nullable_int_with_string_doesnt_cast(self):
+        # GH#25438 don't cast df['a'] to float64
+        df = DataFrame({"a": [1, 2, 3, np.nan], "b": ["some", "strings", "here", "he"]})
+        df["a"] = df["a"].astype("Int64")
+
+        res = df.replace("", np.nan)
+        tm.assert_series_equal(res["a"], df["a"])
+
+    @pytest.mark.parametrize("dtype", ["boolean", "Int64", "Float64"])
+    def test_replace_with_nullable_column(self, dtype):
+        # GH-44499
+        nullable_ser = Series([1, 0, 1], dtype=dtype)
+        df = DataFrame({"A": ["A", "B", "x"], "B": nullable_ser})
+        result = df.replace("x", "X")
+        expected = DataFrame({"A": ["A", "B", "X"], "B": nullable_ser})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_simple_nested_dict(self):
+        df = DataFrame({"col": range(1, 5)})
+        expected = DataFrame({"col": ["a", 2, 3, "b"]})
+
+        result = df.replace({"col": {1: "a", 4: "b"}})
+        tm.assert_frame_equal(expected, result)
+
+        # in this case, should be the same as the not nested version
+        result = df.replace({1: "a", 4: "b"})
+        tm.assert_frame_equal(expected, result)
+
+    def test_replace_simple_nested_dict_with_nonexistent_value(self):
+        df = DataFrame({"col": range(1, 5)})
+        expected = DataFrame({"col": ["a", 2, 3, "b"]})
+
+        result = df.replace({-1: "-", 1: "a", 4: "b"})
+        tm.assert_frame_equal(expected, result)
+
+        result = df.replace({"col": {-1: "-", 1: "a", 4: "b"}})
+        tm.assert_frame_equal(expected, result)
+
+    def test_replace_NA_with_None(self):
+        # gh-45601
+        df = DataFrame({"value": [42, None]}).astype({"value": "Int64"})
+        result = df.replace({pd.NA: None})
+        expected = DataFrame({"value": [42, None]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_NAT_with_None(self):
+        # gh-45836
+        df = DataFrame([pd.NaT, pd.NaT])
+        result = df.replace({pd.NaT: None, np.nan: None})
+        expected = DataFrame([None, None])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_with_None_keeps_categorical(self):
+        # gh-46634
+        cat_series = Series(["b", "b", "b", "d"], dtype="category")
+        df = DataFrame(
+            {
+                "id": Series([5, 4, 3, 2], dtype="float64"),
+                "col": cat_series,
+            }
+        )
+        result = df.replace({3: None})
+
+        expected = DataFrame(
+            {
+                "id": Series([5.0, 4.0, None, 2.0], dtype="object"),
+                "col": cat_series,
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_value_is_none(self, datetime_frame):
+        orig_value = datetime_frame.iloc[0, 0]
+        orig2 = datetime_frame.iloc[1, 0]
+
+        datetime_frame.iloc[0, 0] = np.nan
+        datetime_frame.iloc[1, 0] = 1
+
+        result = datetime_frame.replace(to_replace={np.nan: 0})
+        expected = datetime_frame.T.replace(to_replace={np.nan: 0}).T
+        tm.assert_frame_equal(result, expected)
+
+        result = datetime_frame.replace(to_replace={np.nan: 0, 1: -1e8})
+        tsframe = datetime_frame.copy()
+        tsframe.iloc[0, 0] = 0
+        tsframe.iloc[1, 0] = -1e8
+        expected = tsframe
+        tm.assert_frame_equal(expected, result)
+        datetime_frame.iloc[0, 0] = orig_value
+        datetime_frame.iloc[1, 0] = orig2
+
+    def test_replace_for_new_dtypes(self, datetime_frame):
+        # dtypes
+        tsframe = datetime_frame.copy().astype(np.float32)
+        tsframe.loc[tsframe.index[:5], "A"] = np.nan
+        tsframe.loc[tsframe.index[-5:], "A"] = np.nan
+
+        zero_filled = tsframe.replace(np.nan, -1e8)
+        tm.assert_frame_equal(zero_filled, tsframe.fillna(-1e8))
+        tm.assert_frame_equal(zero_filled.replace(-1e8, np.nan), tsframe)
+
+        tsframe.loc[tsframe.index[:5], "A"] = np.nan
+        tsframe.loc[tsframe.index[-5:], "A"] = np.nan
+        tsframe.loc[tsframe.index[:5], "B"] = -1e8
+
+        b = tsframe["B"]
+        b[b == -1e8] = np.nan
+        tsframe["B"] = b
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            # TODO: what is this even testing?
+            result = tsframe.fillna(method="bfill")
+            tm.assert_frame_equal(result, tsframe.fillna(method="bfill"))
+
+    @pytest.mark.parametrize(
+        "frame, to_replace, value, expected",
+        [
+            (DataFrame({"ints": [1, 2, 3]}), 1, 0, DataFrame({"ints": [0, 2, 3]})),
+            (
+                DataFrame({"ints": [1, 2, 3]}, dtype=np.int32),
+                1,
+                0,
+                DataFrame({"ints": [0, 2, 3]}, dtype=np.int32),
+            ),
+            (
+                DataFrame({"ints": [1, 2, 3]}, dtype=np.int16),
+                1,
+                0,
+                DataFrame({"ints": [0, 2, 3]}, dtype=np.int16),
+            ),
+            (
+                DataFrame({"bools": [True, False, True]}),
+                False,
+                True,
+                DataFrame({"bools": [True, True, True]}),
+            ),
+            (
+                DataFrame({"complex": [1j, 2j, 3j]}),
+                1j,
+                0,
+                DataFrame({"complex": [0j, 2j, 3j]}),
+            ),
+            (
+                DataFrame(
+                    {
+                        "datetime64": Index(
+                            [
+                                datetime(2018, 5, 28),
+                                datetime(2018, 7, 28),
+                                datetime(2018, 5, 28),
+                            ]
+                        )
+                    }
+                ),
+                datetime(2018, 5, 28),
+                datetime(2018, 7, 28),
+                DataFrame({"datetime64": Index([datetime(2018, 7, 28)] * 3)}),
+            ),
+            # GH 20380
+            (
+                DataFrame({"dt": [datetime(3017, 12, 20)], "str": ["foo"]}),
+                "foo",
+                "bar",
+                DataFrame({"dt": [datetime(3017, 12, 20)], "str": ["bar"]}),
+            ),
+            # GH 36782
+            (
+                DataFrame({"dt": [datetime(2920, 10, 1)]}),
+                datetime(2920, 10, 1),
+                datetime(2020, 10, 1),
+                DataFrame({"dt": [datetime(2020, 10, 1)]}),
+            ),
+            (
+                DataFrame(
+                    {
+                        "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                        "B": [0, np.nan, 2],
+                    }
+                ),
+                Timestamp("20130102", tz="US/Eastern"),
+                Timestamp("20130104", tz="US/Eastern"),
+                DataFrame(
+                    {
+                        "A": [
+                            Timestamp("20130101", tz="US/Eastern"),
+                            Timestamp("20130104", tz="US/Eastern"),
+                            Timestamp("20130103", tz="US/Eastern"),
+                        ],
+                        "B": [0, np.nan, 2],
+                    }
+                ),
+            ),
+            # GH 35376
+            (
+                DataFrame([[1, 1.0], [2, 2.0]]),
+                1.0,
+                5,
+                DataFrame([[5, 5.0], [2, 2.0]]),
+            ),
+            (
+                DataFrame([[1, 1.0], [2, 2.0]]),
+                1,
+                5,
+                DataFrame([[5, 5.0], [2, 2.0]]),
+            ),
+            (
+                DataFrame([[1, 1.0], [2, 2.0]]),
+                1.0,
+                5.0,
+                DataFrame([[5, 5.0], [2, 2.0]]),
+            ),
+            (
+                DataFrame([[1, 1.0], [2, 2.0]]),
+                1,
+                5.0,
+                DataFrame([[5, 5.0], [2, 2.0]]),
+            ),
+        ],
+    )
+    def test_replace_dtypes(self, frame, to_replace, value, expected):
+        result = frame.replace(to_replace, value)
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_input_formats_listlike(self):
+        # both dicts
+        to_rep = {"A": np.nan, "B": 0, "C": ""}
+        values = {"A": 0, "B": -1, "C": "missing"}
+        df = DataFrame(
+            {"A": [np.nan, 0, np.inf], "B": [0, 2, 5], "C": ["", "asdf", "fd"]}
+        )
+        filled = df.replace(to_rep, values)
+        expected = {k: v.replace(to_rep[k], values[k]) for k, v in df.items()}
+        tm.assert_frame_equal(filled, DataFrame(expected))
+
+        result = df.replace([0, 2, 5], [5, 2, 0])
+        expected = DataFrame(
+            {"A": [np.nan, 5, np.inf], "B": [5, 2, 0], "C": ["", "asdf", "fd"]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # scalar to dict
+        values = {"A": 0, "B": -1, "C": "missing"}
+        df = DataFrame(
+            {"A": [np.nan, 0, np.nan], "B": [0, 2, 5], "C": ["", "asdf", "fd"]}
+        )
+        filled = df.replace(np.nan, values)
+        expected = {k: v.replace(np.nan, values[k]) for k, v in df.items()}
+        tm.assert_frame_equal(filled, DataFrame(expected))
+
+        # list to list
+        to_rep = [np.nan, 0, ""]
+        values = [-2, -1, "missing"]
+        result = df.replace(to_rep, values)
+        expected = df.copy()
+        for rep, value in zip(to_rep, values):
+            return_value = expected.replace(rep, value, inplace=True)
+            assert return_value is None
+        tm.assert_frame_equal(result, expected)
+
+        msg = r"Replacement lists must match in length\. Expecting 3 got 2"
+        with pytest.raises(ValueError, match=msg):
+            df.replace(to_rep, values[1:])
+
+    def test_replace_input_formats_scalar(self):
+        df = DataFrame(
+            {"A": [np.nan, 0, np.inf], "B": [0, 2, 5], "C": ["", "asdf", "fd"]}
+        )
+
+        # dict to scalar
+        to_rep = {"A": np.nan, "B": 0, "C": ""}
+        filled = df.replace(to_rep, 0)
+        expected = {k: v.replace(to_rep[k], 0) for k, v in df.items()}
+        tm.assert_frame_equal(filled, DataFrame(expected))
+
+        msg = "value argument must be scalar, dict, or Series"
+        with pytest.raises(TypeError, match=msg):
+            df.replace(to_rep, [np.nan, 0, ""])
+
+        # list to scalar
+        to_rep = [np.nan, 0, ""]
+        result = df.replace(to_rep, -1)
+        expected = df.copy()
+        for rep in to_rep:
+            return_value = expected.replace(rep, -1, inplace=True)
+            assert return_value is None
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_limit(self):
+        # TODO
+        pass
+
+    def test_replace_dict_no_regex(self):
+        answer = Series(
+            {
+                0: "Strongly Agree",
+                1: "Agree",
+                2: "Neutral",
+                3: "Disagree",
+                4: "Strongly Disagree",
+            }
+        )
+        weights = {
+            "Agree": 4,
+            "Disagree": 2,
+            "Neutral": 3,
+            "Strongly Agree": 5,
+            "Strongly Disagree": 1,
+        }
+        expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1})
+        result = answer.replace(weights)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_series_no_regex(self):
+        answer = Series(
+            {
+                0: "Strongly Agree",
+                1: "Agree",
+                2: "Neutral",
+                3: "Disagree",
+                4: "Strongly Disagree",
+            }
+        )
+        weights = Series(
+            {
+                "Agree": 4,
+                "Disagree": 2,
+                "Neutral": 3,
+                "Strongly Agree": 5,
+                "Strongly Disagree": 1,
+            }
+        )
+        expected = Series({0: 5, 1: 4, 2: 3, 3: 2, 4: 1})
+        result = answer.replace(weights)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_dict_tuple_list_ordering_remains_the_same(self):
+        df = DataFrame({"A": [np.nan, 1]})
+        res1 = df.replace(to_replace={np.nan: 0, 1: -1e8})
+        res2 = df.replace(to_replace=(1, np.nan), value=[-1e8, 0])
+        res3 = df.replace(to_replace=[1, np.nan], value=[-1e8, 0])
+
+        expected = DataFrame({"A": [0, -1e8]})
+        tm.assert_frame_equal(res1, res2)
+        tm.assert_frame_equal(res2, res3)
+        tm.assert_frame_equal(res3, expected)
+
+    def test_replace_doesnt_replace_without_regex(self):
+        df = DataFrame(
+            {
+                "fol": [1, 2, 2, 3],
+                "T_opp": ["0", "vr", "0", "0"],
+                "T_Dir": ["0", "0", "0", "bt"],
+                "T_Enh": ["vo", "0", "0", "0"],
+            }
+        )
+        res = df.replace({r"\D": 1})
+        tm.assert_frame_equal(df, res)
+
+    def test_replace_bool_with_string(self):
+        df = DataFrame({"a": [True, False], "b": list("ab")})
+        result = df.replace(True, "a")
+        expected = DataFrame({"a": ["a", False], "b": df.b})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_pure_bool_with_string_no_op(self):
+        df = DataFrame(np.random.default_rng(2).random((2, 2)) > 0.5)
+        result = df.replace("asdf", "fdsa")
+        tm.assert_frame_equal(df, result)
+
+    def test_replace_bool_with_bool(self):
+        df = DataFrame(np.random.default_rng(2).random((2, 2)) > 0.5)
+        result = df.replace(False, True)
+        expected = DataFrame(np.ones((2, 2), dtype=bool))
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_with_dict_with_bool_keys(self):
+        df = DataFrame({0: [True, False], 1: [False, True]})
+        result = df.replace({"asdf": "asdb", True: "yes"})
+        expected = DataFrame({0: ["yes", False], 1: [False, "yes"]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_dict_strings_vs_ints(self):
+        # GH#34789
+        df = DataFrame({"Y0": [1, 2], "Y1": [3, 4]})
+        result = df.replace({"replace_string": "test"})
+
+        tm.assert_frame_equal(result, df)
+
+        result = df["Y0"].replace({"replace_string": "test"})
+        tm.assert_series_equal(result, df["Y0"])
+
+    def test_replace_truthy(self):
+        df = DataFrame({"a": [True, True]})
+        r = df.replace([np.inf, -np.inf], np.nan)
+        e = df
+        tm.assert_frame_equal(r, e)
+
+    def test_nested_dict_overlapping_keys_replace_int(self):
+        # GH 27660 keep behaviour consistent for simple dictionary and
+        # nested dictionary replacement
+        df = DataFrame({"a": list(range(1, 5))})
+
+        result = df.replace({"a": dict(zip(range(1, 5), range(2, 6)))})
+        expected = df.replace(dict(zip(range(1, 5), range(2, 6))))
+        tm.assert_frame_equal(result, expected)
+
+    def test_nested_dict_overlapping_keys_replace_str(self):
+        # GH 27660
+        a = np.arange(1, 5)
+        astr = a.astype(str)
+        bstr = np.arange(2, 6).astype(str)
+        df = DataFrame({"a": astr})
+        result = df.replace(dict(zip(astr, bstr)))
+        expected = df.replace({"a": dict(zip(astr, bstr))})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_swapping_bug(self):
+        df = DataFrame({"a": [True, False, True]})
+        res = df.replace({"a": {True: "Y", False: "N"}})
+        expect = DataFrame({"a": ["Y", "N", "Y"]})
+        tm.assert_frame_equal(res, expect)
+
+        df = DataFrame({"a": [0, 1, 0]})
+        res = df.replace({"a": {0: "Y", 1: "N"}})
+        expect = DataFrame({"a": ["Y", "N", "Y"]})
+        tm.assert_frame_equal(res, expect)
+
+    def test_replace_period(self):
+        d = {
+            "fname": {
+                "out_augmented_AUG_2011.json": pd.Period(year=2011, month=8, freq="M"),
+                "out_augmented_JAN_2011.json": pd.Period(year=2011, month=1, freq="M"),
+                "out_augmented_MAY_2012.json": pd.Period(year=2012, month=5, freq="M"),
+                "out_augmented_SUBSIDY_WEEK.json": pd.Period(
+                    year=2011, month=4, freq="M"
+                ),
+                "out_augmented_AUG_2012.json": pd.Period(year=2012, month=8, freq="M"),
+                "out_augmented_MAY_2011.json": pd.Period(year=2011, month=5, freq="M"),
+                "out_augmented_SEP_2013.json": pd.Period(year=2013, month=9, freq="M"),
+            }
+        }
+
+        df = DataFrame(
+            [
+                "out_augmented_AUG_2012.json",
+                "out_augmented_SEP_2013.json",
+                "out_augmented_SUBSIDY_WEEK.json",
+                "out_augmented_MAY_2012.json",
+                "out_augmented_MAY_2011.json",
+                "out_augmented_AUG_2011.json",
+                "out_augmented_JAN_2011.json",
+            ],
+            columns=["fname"],
+        )
+        assert set(df.fname.values) == set(d["fname"].keys())
+
+        expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]})
+        assert expected.dtypes.iloc[0] == "Period[M]"
+        result = df.replace(d)
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_datetime(self):
+        d = {
+            "fname": {
+                "out_augmented_AUG_2011.json": Timestamp("2011-08"),
+                "out_augmented_JAN_2011.json": Timestamp("2011-01"),
+                "out_augmented_MAY_2012.json": Timestamp("2012-05"),
+                "out_augmented_SUBSIDY_WEEK.json": Timestamp("2011-04"),
+                "out_augmented_AUG_2012.json": Timestamp("2012-08"),
+                "out_augmented_MAY_2011.json": Timestamp("2011-05"),
+                "out_augmented_SEP_2013.json": Timestamp("2013-09"),
+            }
+        }
+
+        df = DataFrame(
+            [
+                "out_augmented_AUG_2012.json",
+                "out_augmented_SEP_2013.json",
+                "out_augmented_SUBSIDY_WEEK.json",
+                "out_augmented_MAY_2012.json",
+                "out_augmented_MAY_2011.json",
+                "out_augmented_AUG_2011.json",
+                "out_augmented_JAN_2011.json",
+            ],
+            columns=["fname"],
+        )
+        assert set(df.fname.values) == set(d["fname"].keys())
+        expected = DataFrame({"fname": [d["fname"][k] for k in df.fname.values]})
+        result = df.replace(d)
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_datetimetz(self):
+        # GH 11326
+        # behaving poorly when presented with a datetime64[ns, tz]
+        df = DataFrame(
+            {
+                "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                "B": [0, np.nan, 2],
+            }
+        )
+        result = df.replace(np.nan, 1)
+        expected = DataFrame(
+            {
+                "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                "B": Series([0, 1, 2], dtype="float64"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.fillna(1)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.replace(0, np.nan)
+        expected = DataFrame(
+            {
+                "A": date_range("20130101", periods=3, tz="US/Eastern"),
+                "B": [np.nan, np.nan, 2],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.replace(
+            Timestamp("20130102", tz="US/Eastern"),
+            Timestamp("20130104", tz="US/Eastern"),
+        )
+        expected = DataFrame(
+            {
+                "A": [
+                    Timestamp("20130101", tz="US/Eastern"),
+                    Timestamp("20130104", tz="US/Eastern"),
+                    Timestamp("20130103", tz="US/Eastern"),
+                ],
+                "B": [0, np.nan, 2],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.iloc[1, 0] = np.nan
+        result = result.replace({"A": pd.NaT}, Timestamp("20130104", tz="US/Eastern"))
+        tm.assert_frame_equal(result, expected)
+
+        # pre-2.0 this would coerce to object with mismatched tzs
+        result = df.copy()
+        result.iloc[1, 0] = np.nan
+        result = result.replace({"A": pd.NaT}, Timestamp("20130104", tz="US/Pacific"))
+        expected = DataFrame(
+            {
+                "A": [
+                    Timestamp("20130101", tz="US/Eastern"),
+                    Timestamp("20130104", tz="US/Pacific").tz_convert("US/Eastern"),
+                    Timestamp("20130103", tz="US/Eastern"),
+                ],
+                "B": [0, np.nan, 2],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.copy()
+        result.iloc[1, 0] = np.nan
+        result = result.replace({"A": np.nan}, Timestamp("20130104"))
+        expected = DataFrame(
+            {
+                "A": [
+                    Timestamp("20130101", tz="US/Eastern"),
+                    Timestamp("20130104"),
+                    Timestamp("20130103", tz="US/Eastern"),
+                ],
+                "B": [0, np.nan, 2],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_with_empty_dictlike(self, mix_abc):
+        # GH 15289
+        df = DataFrame(mix_abc)
+        tm.assert_frame_equal(df, df.replace({}))
+        tm.assert_frame_equal(df, df.replace(Series([], dtype=object)))
+
+        tm.assert_frame_equal(df, df.replace({"b": {}}))
+        tm.assert_frame_equal(df, df.replace(Series({"b": {}})))
+
+    @pytest.mark.parametrize(
+        "to_replace, method, expected",
+        [
+            (0, "bfill", {"A": [1, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]}),
+            (
+                np.nan,
+                "bfill",
+                {"A": [0, 1, 2], "B": [5.0, 7.0, 7.0], "C": ["a", "b", "c"]},
+            ),
+            ("d", "ffill", {"A": [0, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]}),
+            (
+                [0, 2],
+                "bfill",
+                {"A": [1, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]},
+            ),
+            (
+                [1, 2],
+                "pad",
+                {"A": [0, 0, 0], "B": [5, np.nan, 7], "C": ["a", "b", "c"]},
+            ),
+            (
+                (1, 2),
+                "bfill",
+                {"A": [0, 2, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]},
+            ),
+            (
+                ["b", "c"],
+                "ffill",
+                {"A": [0, 1, 2], "B": [5, np.nan, 7], "C": ["a", "a", "a"]},
+            ),
+        ],
+    )
+    def test_replace_method(self, to_replace, method, expected):
+        # GH 19632
+        df = DataFrame({"A": [0, 1, 2], "B": [5, np.nan, 7], "C": ["a", "b", "c"]})
+
+        msg = "The 'method' keyword in DataFrame.replace is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.replace(to_replace=to_replace, value=None, method=method)
+        expected = DataFrame(expected)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "replace_dict, final_data",
+        [({"a": 1, "b": 1}, [[3, 3], [2, 2]]), ({"a": 1, "b": 2}, [[3, 1], [2, 3]])],
+    )
+    def test_categorical_replace_with_dict(self, replace_dict, final_data):
+        # GH 26988
+        df = DataFrame([[1, 1], [2, 2]], columns=["a", "b"], dtype="category")
+
+        final_data = np.array(final_data)
+
+        a = pd.Categorical(final_data[:, 0], categories=[3, 2])
+
+        ex_cat = [3, 2] if replace_dict["b"] == 1 else [1, 3]
+        b = pd.Categorical(final_data[:, 1], categories=ex_cat)
+
+        expected = DataFrame({"a": a, "b": b})
+        result = df.replace(replace_dict, 3)
+        tm.assert_frame_equal(result, expected)
+        msg = (
+            r"Attributes of DataFrame.iloc\[:, 0\] \(column name=\"a\"\) are "
+            "different"
+        )
+        with pytest.raises(AssertionError, match=msg):
+            # ensure non-inplace call does not affect original
+            tm.assert_frame_equal(df, expected)
+        return_value = df.replace(replace_dict, 3, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "df, to_replace, exp",
+        [
+            (
+                {"col1": [1, 2, 3], "col2": [4, 5, 6]},
+                {4: 5, 5: 6, 6: 7},
+                {"col1": [1, 2, 3], "col2": [5, 6, 7]},
+            ),
+            (
+                {"col1": [1, 2, 3], "col2": ["4", "5", "6"]},
+                {"4": "5", "5": "6", "6": "7"},
+                {"col1": [1, 2, 3], "col2": ["5", "6", "7"]},
+            ),
+        ],
+    )
+    def test_replace_commutative(self, df, to_replace, exp):
+        # GH 16051
+        # DataFrame.replace() overwrites when values are non-numeric
+        # also added to data frame whilst issue was for series
+
+        df = DataFrame(df)
+
+        expected = DataFrame(exp)
+        result = df.replace(to_replace)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "replacer",
+        [
+            Timestamp("20170827"),
+            np.int8(1),
+            np.int16(1),
+            np.float32(1),
+            np.float64(1),
+        ],
+    )
+    def test_replace_replacer_dtype(self, request, replacer):
+        # GH26632
+        df = DataFrame(["a"])
+        result = df.replace({"a": replacer, "b": replacer})
+        expected = DataFrame([replacer])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_after_convert_dtypes(self):
+        # GH31517
+        df = DataFrame({"grp": [1, 2, 3, 4, 5]}, dtype="Int64")
+        result = df.replace(1, 10)
+        expected = DataFrame({"grp": [10, 2, 3, 4, 5]}, dtype="Int64")
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_invalid_to_replace(self):
+        # GH 18634
+        # API: replace() should raise an exception if invalid argument is given
+        df = DataFrame({"one": ["a", "b ", "c"], "two": ["d ", "e ", "f "]})
+        msg = (
+            r"Expecting 'to_replace' to be either a scalar, array-like, "
+            r"dict or None, got invalid type.*"
+        )
+        msg2 = (
+            "DataFrame.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with pytest.raises(TypeError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                df.replace(lambda x: x.strip())
+
+    @pytest.mark.parametrize("dtype", ["float", "float64", "int64", "Int64", "boolean"])
+    @pytest.mark.parametrize("value", [np.nan, pd.NA])
+    def test_replace_no_replacement_dtypes(self, dtype, value):
+        # https://github.com/pandas-dev/pandas/issues/32988
+        df = DataFrame(np.eye(2), dtype=dtype)
+        result = df.replace(to_replace=[None, -np.inf, np.inf], value=value)
+        tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize("replacement", [np.nan, 5])
+    def test_replace_with_duplicate_columns(self, replacement):
+        # GH 24798
+        result = DataFrame({"A": [1, 2, 3], "A1": [4, 5, 6], "B": [7, 8, 9]})
+        result.columns = list("AAB")
+
+        expected = DataFrame(
+            {"A": [1, 2, 3], "A1": [4, 5, 6], "B": [replacement, 8, 9]}
+        )
+        expected.columns = list("AAB")
+
+        result["B"] = result["B"].replace(7, replacement)
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("value", [pd.Period("2020-01"), pd.Interval(0, 5)])
+    def test_replace_ea_ignore_float(self, frame_or_series, value):
+        # GH#34871
+        obj = DataFrame({"Per": [value] * 3})
+        obj = tm.get_obj(obj, frame_or_series)
+
+        expected = obj.copy()
+        result = obj.replace(1.0, 0.0)
+        tm.assert_equal(expected, result)
+
+    def test_replace_value_category_type(self):
+        """
+        Test for #23305: to ensure category dtypes are maintained
+        after replace with direct values
+        """
+
+        # create input data
+        input_dict = {
+            "col1": [1, 2, 3, 4],
+            "col2": ["a", "b", "c", "d"],
+            "col3": [1.5, 2.5, 3.5, 4.5],
+            "col4": ["cat1", "cat2", "cat3", "cat4"],
+            "col5": ["obj1", "obj2", "obj3", "obj4"],
+        }
+        # explicitly cast columns as category and order them
+        input_df = DataFrame(data=input_dict).astype(
+            {"col2": "category", "col4": "category"}
+        )
+        input_df["col2"] = input_df["col2"].cat.reorder_categories(
+            ["a", "b", "c", "d"], ordered=True
+        )
+        input_df["col4"] = input_df["col4"].cat.reorder_categories(
+            ["cat1", "cat2", "cat3", "cat4"], ordered=True
+        )
+
+        # create expected dataframe
+        expected_dict = {
+            "col1": [1, 2, 3, 4],
+            "col2": ["a", "b", "c", "z"],
+            "col3": [1.5, 2.5, 3.5, 4.5],
+            "col4": ["cat1", "catX", "cat3", "cat4"],
+            "col5": ["obj9", "obj2", "obj3", "obj4"],
+        }
+        # explicitly cast columns as category and order them
+        expected = DataFrame(data=expected_dict).astype(
+            {"col2": "category", "col4": "category"}
+        )
+        expected["col2"] = expected["col2"].cat.reorder_categories(
+            ["a", "b", "c", "z"], ordered=True
+        )
+        expected["col4"] = expected["col4"].cat.reorder_categories(
+            ["cat1", "catX", "cat3", "cat4"], ordered=True
+        )
+
+        # replace values in input dataframe
+        input_df = input_df.replace("d", "z")
+        input_df = input_df.replace("obj1", "obj9")
+        result = input_df.replace("cat2", "catX")
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_dict_category_type(self):
+        """
+        Test to ensure category dtypes are maintained
+        after replace with dict values
+        """
+        # GH#35268, GH#44940
+
+        # create input dataframe
+        input_dict = {"col1": ["a"], "col2": ["obj1"], "col3": ["cat1"]}
+        # explicitly cast columns as category
+        input_df = DataFrame(data=input_dict).astype(
+            {"col1": "category", "col2": "category", "col3": "category"}
+        )
+
+        # create expected dataframe
+        expected_dict = {"col1": ["z"], "col2": ["obj9"], "col3": ["catX"]}
+        # explicitly cast columns as category
+        expected = DataFrame(data=expected_dict).astype(
+            {"col1": "category", "col2": "category", "col3": "category"}
+        )
+
+        # replace values in input dataframe using a dict
+        result = input_df.replace({"a": "z", "obj1": "obj9", "cat1": "catX"})
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_with_compiled_regex(self):
+        # https://github.com/pandas-dev/pandas/issues/35680
+        df = DataFrame(["a", "b", "c"])
+        regex = re.compile("^a$")
+        result = df.replace({regex: "z"}, regex=True)
+        expected = DataFrame(["z", "b", "c"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_intervals(self):
+        # https://github.com/pandas-dev/pandas/issues/35931
+        df = DataFrame({"a": [pd.Interval(0, 1), pd.Interval(0, 1)]})
+        result = df.replace({"a": {pd.Interval(0, 1): "x"}})
+        expected = DataFrame({"a": ["x", "x"]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_unicode(self):
+        # GH: 16784
+        columns_values_map = {"positive": {"正面": 1, "中立": 1, "负面": 0}}
+        df1 = DataFrame({"positive": np.ones(3)})
+        result = df1.replace(columns_values_map)
+        expected = DataFrame({"positive": np.ones(3)})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_bytes(self, frame_or_series):
+        # GH#38900
+        obj = frame_or_series(["o"]).astype("|S")
+        expected = obj.copy()
+        obj = obj.replace({None: np.nan})
+        tm.assert_equal(obj, expected)
+
+    @pytest.mark.parametrize(
+        "data, to_replace, value, expected",
+        [
+            ([1], [1.0], [0], [0]),
+            ([1], [1], [0], [0]),
+            ([1.0], [1.0], [0], [0.0]),
+            ([1.0], [1], [0], [0.0]),
+        ],
+    )
+    @pytest.mark.parametrize("box", [list, tuple, np.array])
+    def test_replace_list_with_mixed_type(
+        self, data, to_replace, value, expected, box, frame_or_series
+    ):
+        # GH#40371
+        obj = frame_or_series(data)
+        expected = frame_or_series(expected)
+        result = obj.replace(box(to_replace), value)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [2, np.nan, 2.0])
+    def test_replace_value_none_dtype_numeric(self, val):
+        # GH#48231
+        df = DataFrame({"a": [1, val]})
+        result = df.replace(val, None)
+        expected = DataFrame({"a": [1, None]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+        df = DataFrame({"a": [1, val]})
+        result = df.replace({val: None})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_with_nil_na(self):
+        # GH 32075
+        ser = DataFrame({"a": ["nil", pd.NA]})
+        expected = DataFrame({"a": ["anything else", pd.NA]}, index=[0, 1])
+        result = ser.replace("nil", "anything else")
+        tm.assert_frame_equal(expected, result)
+
+
+class TestDataFrameReplaceRegex:
+    @pytest.mark.parametrize(
+        "data",
+        [
+            {"a": list("ab.."), "b": list("efgh")},
+            {"a": list("ab.."), "b": list(range(4))},
+        ],
+    )
+    @pytest.mark.parametrize(
+        "to_replace,value", [(r"\s*\.\s*", np.nan), (r"\s*(\.)\s*", r"\1\1\1")]
+    )
+    @pytest.mark.parametrize("compile_regex", [True, False])
+    @pytest.mark.parametrize("regex_kwarg", [True, False])
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_regex_replace_scalar(
+        self, data, to_replace, value, compile_regex, regex_kwarg, inplace
+    ):
+        df = DataFrame(data)
+        expected = df.copy()
+
+        if compile_regex:
+            to_replace = re.compile(to_replace)
+
+        if regex_kwarg:
+            regex = to_replace
+            to_replace = None
+        else:
+            regex = True
+
+        result = df.replace(to_replace, value, inplace=inplace, regex=regex)
+
+        if inplace:
+            assert result is None
+            result = df
+
+        if value is np.nan:
+            expected_replace_val = np.nan
+        else:
+            expected_replace_val = "..."
+
+        expected.loc[expected["a"] == ".", "a"] = expected_replace_val
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("regex", [False, True])
+    def test_replace_regex_dtype_frame(self, regex):
+        # GH-48644
+        df1 = DataFrame({"A": ["0"], "B": ["0"]})
+        expected_df1 = DataFrame({"A": [1], "B": [1]})
+        result_df1 = df1.replace(to_replace="0", value=1, regex=regex)
+        tm.assert_frame_equal(result_df1, expected_df1)
+
+        df2 = DataFrame({"A": ["0"], "B": ["1"]})
+        expected_df2 = DataFrame({"A": [1], "B": ["1"]})
+        result_df2 = df2.replace(to_replace="0", value=1, regex=regex)
+        tm.assert_frame_equal(result_df2, expected_df2)
+
+    def test_replace_with_value_also_being_replaced(self):
+        # GH46306
+        df = DataFrame({"A": [0, 1, 2], "B": [1, 0, 2]})
+        result = df.replace({0: 1, 1: np.nan})
+        expected = DataFrame({"A": [1, np.nan, 2], "B": [np.nan, 1, 2]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_categorical_no_replacement(self):
+        # GH#46672
+        df = DataFrame(
+            {
+                "a": ["one", "two", None, "three"],
+                "b": ["one", None, "two", "three"],
+            },
+            dtype="category",
+        )
+        expected = df.copy()
+
+        result = df.replace(to_replace=[".", "def"], value=["_", None])
+        tm.assert_frame_equal(result, expected)
+
+    def test_replace_object_splitting(self):
+        # GH#53977
+        df = DataFrame({"a": ["a"], "b": "b"})
+        assert len(df._mgr.blocks) == 1
+        df.replace(to_replace=r"^\s*$", value="", inplace=True, regex=True)
+        assert len(df._mgr.blocks) == 1
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reset_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reset_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..d99dd36f3a2e331e5e8a1da96457c6b2c8c58bbc
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_reset_index.py
@@ -0,0 +1,802 @@
+from datetime import datetime
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import (
+    is_float_dtype,
+    is_integer_dtype,
+)
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DataFrame,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    Timestamp,
+    cut,
+    date_range,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture()
+def multiindex_df():
+    levels = [["A", ""], ["B", "b"]]
+    return DataFrame([[0, 2], [1, 3]], columns=MultiIndex.from_tuples(levels))
+
+
+class TestResetIndex:
+    def test_reset_index_empty_rangeindex(self):
+        # GH#45230
+        df = DataFrame(
+            columns=["brand"], dtype=np.int64, index=RangeIndex(0, 0, 1, name="foo")
+        )
+
+        df2 = df.set_index([df.index, "brand"])
+
+        result = df2.reset_index([1], drop=True)
+        tm.assert_frame_equal(result, df[[]], check_index_type=True)
+
+    def test_set_reset(self):
+        idx = Index([2**63, 2**63 + 5, 2**63 + 10], name="foo")
+
+        # set/reset
+        df = DataFrame({"A": [0, 1, 2]}, index=idx)
+        result = df.reset_index()
+        assert result["foo"].dtype == np.dtype("uint64")
+
+        df = result.set_index("foo")
+        tm.assert_index_equal(df.index, idx)
+
+    def test_set_index_reset_index_dt64tz(self):
+        idx = Index(date_range("20130101", periods=3, tz="US/Eastern"), name="foo")
+
+        # set/reset
+        df = DataFrame({"A": [0, 1, 2]}, index=idx)
+        result = df.reset_index()
+        assert result["foo"].dtype == "datetime64[ns, US/Eastern]"
+
+        df = result.set_index("foo")
+        tm.assert_index_equal(df.index, idx)
+
+    def test_reset_index_tz(self, tz_aware_fixture):
+        # GH 3950
+        # reset_index with single level
+        tz = tz_aware_fixture
+        idx = date_range("1/1/2011", periods=5, freq="D", tz=tz, name="idx")
+        df = DataFrame({"a": range(5), "b": ["A", "B", "C", "D", "E"]}, index=idx)
+
+        expected = DataFrame(
+            {
+                "idx": [
+                    datetime(2011, 1, 1),
+                    datetime(2011, 1, 2),
+                    datetime(2011, 1, 3),
+                    datetime(2011, 1, 4),
+                    datetime(2011, 1, 5),
+                ],
+                "a": range(5),
+                "b": ["A", "B", "C", "D", "E"],
+            },
+            columns=["idx", "a", "b"],
+        )
+        expected["idx"] = expected["idx"].apply(lambda d: Timestamp(d, tz=tz))
+        tm.assert_frame_equal(df.reset_index(), expected)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_frame_reset_index_tzaware_index(self, tz):
+        dr = date_range("2012-06-02", periods=10, tz=tz)
+        df = DataFrame(np.random.default_rng(2).standard_normal(len(dr)), dr)
+        roundtripped = df.reset_index().set_index("index")
+        xp = df.index.tz
+        rs = roundtripped.index.tz
+        assert xp == rs
+
+    def test_reset_index_with_intervals(self):
+        idx = IntervalIndex.from_breaks(np.arange(11), name="x")
+        original = DataFrame({"x": idx, "y": np.arange(10)})[["x", "y"]]
+
+        result = original.set_index("x")
+        expected = DataFrame({"y": np.arange(10)}, index=idx)
+        tm.assert_frame_equal(result, expected)
+
+        result2 = result.reset_index()
+        tm.assert_frame_equal(result2, original)
+
+    def test_reset_index(self, float_frame):
+        stacked = float_frame.stack(future_stack=True)[::2]
+        stacked = DataFrame({"foo": stacked, "bar": stacked})
+
+        names = ["first", "second"]
+        stacked.index.names = names
+        deleveled = stacked.reset_index()
+        for i, (lev, level_codes) in enumerate(
+            zip(stacked.index.levels, stacked.index.codes)
+        ):
+            values = lev.take(level_codes)
+            name = names[i]
+            tm.assert_index_equal(values, Index(deleveled[name]))
+
+        stacked.index.names = [None, None]
+        deleveled2 = stacked.reset_index()
+        tm.assert_series_equal(
+            deleveled["first"], deleveled2["level_0"], check_names=False
+        )
+        tm.assert_series_equal(
+            deleveled["second"], deleveled2["level_1"], check_names=False
+        )
+
+        # default name assigned
+        rdf = float_frame.reset_index()
+        exp = Series(float_frame.index.values, name="index")
+        tm.assert_series_equal(rdf["index"], exp)
+
+        # default name assigned, corner case
+        df = float_frame.copy()
+        df["index"] = "foo"
+        rdf = df.reset_index()
+        exp = Series(float_frame.index.values, name="level_0")
+        tm.assert_series_equal(rdf["level_0"], exp)
+
+        # but this is ok
+        float_frame.index.name = "index"
+        deleveled = float_frame.reset_index()
+        tm.assert_series_equal(deleveled["index"], Series(float_frame.index))
+        tm.assert_index_equal(deleveled.index, Index(range(len(deleveled))), exact=True)
+
+        # preserve column names
+        float_frame.columns.name = "columns"
+        reset = float_frame.reset_index()
+        assert reset.columns.name == "columns"
+
+        # only remove certain columns
+        df = float_frame.reset_index().set_index(["index", "A", "B"])
+        rs = df.reset_index(["A", "B"])
+
+        tm.assert_frame_equal(rs, float_frame)
+
+        rs = df.reset_index(["index", "A", "B"])
+        tm.assert_frame_equal(rs, float_frame.reset_index())
+
+        rs = df.reset_index(["index", "A", "B"])
+        tm.assert_frame_equal(rs, float_frame.reset_index())
+
+        rs = df.reset_index("A")
+        xp = float_frame.reset_index().set_index(["index", "B"])
+        tm.assert_frame_equal(rs, xp)
+
+        # test resetting in place
+        df = float_frame.copy()
+        reset = float_frame.reset_index()
+        return_value = df.reset_index(inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(df, reset)
+
+        df = float_frame.reset_index().set_index(["index", "A", "B"])
+        rs = df.reset_index("A", drop=True)
+        xp = float_frame.copy()
+        del xp["A"]
+        xp = xp.set_index(["B"], append=True)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_reset_index_name(self):
+        df = DataFrame(
+            [[1, 2, 3, 4], [5, 6, 7, 8]],
+            columns=["A", "B", "C", "D"],
+            index=Index(range(2), name="x"),
+        )
+        assert df.reset_index().index.name is None
+        assert df.reset_index(drop=True).index.name is None
+        return_value = df.reset_index(inplace=True)
+        assert return_value is None
+        assert df.index.name is None
+
+    @pytest.mark.parametrize("levels", [["A", "B"], [0, 1]])
+    def test_reset_index_level(self, levels):
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "C", "D"])
+
+        # With MultiIndex
+        result = df.set_index(["A", "B"]).reset_index(level=levels[0])
+        tm.assert_frame_equal(result, df.set_index("B"))
+
+        result = df.set_index(["A", "B"]).reset_index(level=levels[:1])
+        tm.assert_frame_equal(result, df.set_index("B"))
+
+        result = df.set_index(["A", "B"]).reset_index(level=levels)
+        tm.assert_frame_equal(result, df)
+
+        result = df.set_index(["A", "B"]).reset_index(level=levels, drop=True)
+        tm.assert_frame_equal(result, df[["C", "D"]])
+
+        # With single-level Index (GH 16263)
+        result = df.set_index("A").reset_index(level=levels[0])
+        tm.assert_frame_equal(result, df)
+
+        result = df.set_index("A").reset_index(level=levels[:1])
+        tm.assert_frame_equal(result, df)
+
+        result = df.set_index(["A"]).reset_index(level=levels[0], drop=True)
+        tm.assert_frame_equal(result, df[["B", "C", "D"]])
+
+    @pytest.mark.parametrize("idx_lev", [["A", "B"], ["A"]])
+    def test_reset_index_level_missing(self, idx_lev):
+        # Missing levels - for both MultiIndex and single-level Index:
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]], columns=["A", "B", "C", "D"])
+
+        with pytest.raises(KeyError, match=r"(L|l)evel \(?E\)?"):
+            df.set_index(idx_lev).reset_index(level=["A", "E"])
+        with pytest.raises(IndexError, match="Too many levels"):
+            df.set_index(idx_lev).reset_index(level=[0, 1, 2])
+
+    def test_reset_index_right_dtype(self):
+        time = np.arange(0.0, 10, np.sqrt(2) / 2)
+        s1 = Series(
+            (9.81 * time**2) / 2, index=Index(time, name="time"), name="speed"
+        )
+        df = DataFrame(s1)
+
+        reset = s1.reset_index()
+        assert reset["time"].dtype == np.float64
+
+        reset = df.reset_index()
+        assert reset["time"].dtype == np.float64
+
+    def test_reset_index_multiindex_col(self):
+        vals = np.random.default_rng(2).standard_normal((3, 3)).astype(object)
+        idx = ["x", "y", "z"]
+        full = np.hstack(([[x] for x in idx], vals))
+        df = DataFrame(
+            vals,
+            Index(idx, name="a"),
+            columns=[["b", "b", "c"], ["mean", "median", "mean"]],
+        )
+        rs = df.reset_index()
+        xp = DataFrame(
+            full, columns=[["a", "b", "b", "c"], ["", "mean", "median", "mean"]]
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index(col_fill=None)
+        xp = DataFrame(
+            full, columns=[["a", "b", "b", "c"], ["a", "mean", "median", "mean"]]
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index(col_level=1, col_fill="blah")
+        xp = DataFrame(
+            full, columns=[["blah", "b", "b", "c"], ["a", "mean", "median", "mean"]]
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        df = DataFrame(
+            vals,
+            MultiIndex.from_arrays([[0, 1, 2], ["x", "y", "z"]], names=["d", "a"]),
+            columns=[["b", "b", "c"], ["mean", "median", "mean"]],
+        )
+        rs = df.reset_index("a")
+        xp = DataFrame(
+            full,
+            Index([0, 1, 2], name="d"),
+            columns=[["a", "b", "b", "c"], ["", "mean", "median", "mean"]],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index("a", col_fill=None)
+        xp = DataFrame(
+            full,
+            Index(range(3), name="d"),
+            columns=[["a", "b", "b", "c"], ["a", "mean", "median", "mean"]],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = df.reset_index("a", col_fill="blah", col_level=1)
+        xp = DataFrame(
+            full,
+            Index(range(3), name="d"),
+            columns=[["blah", "b", "b", "c"], ["a", "mean", "median", "mean"]],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+    def test_reset_index_multiindex_nan(self):
+        # GH#6322, testing reset_index on MultiIndexes
+        # when we have a nan or all nan
+        df = DataFrame(
+            {
+                "A": ["a", "b", "c"],
+                "B": [0, 1, np.nan],
+                "C": np.random.default_rng(2).random(3),
+            }
+        )
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+        df = DataFrame(
+            {
+                "A": [np.nan, "b", "c"],
+                "B": [0, 1, 2],
+                "C": np.random.default_rng(2).random(3),
+            }
+        )
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+        df = DataFrame({"A": ["a", "b", "c"], "B": [0, 1, 2], "C": [np.nan, 1.1, 2.2]})
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+        df = DataFrame(
+            {
+                "A": ["a", "b", "c"],
+                "B": [np.nan, np.nan, np.nan],
+                "C": np.random.default_rng(2).random(3),
+            }
+        )
+        rs = df.set_index(["A", "B"]).reset_index()
+        tm.assert_frame_equal(rs, df)
+
+    @pytest.mark.parametrize(
+        "name",
+        [
+            None,
+            "foo",
+            2,
+            3.0,
+            pd.Timedelta(6),
+            Timestamp("2012-12-30", tz="UTC"),
+            "2012-12-31",
+        ],
+    )
+    def test_reset_index_with_datetimeindex_cols(self, name):
+        # GH#5818
+        df = DataFrame(
+            [[1, 2], [3, 4]],
+            columns=date_range("1/1/2013", "1/2/2013"),
+            index=["A", "B"],
+        )
+        df.index.name = name
+
+        result = df.reset_index()
+
+        item = name if name is not None else "index"
+        columns = Index([item, datetime(2013, 1, 1), datetime(2013, 1, 2)])
+        if isinstance(item, str) and item == "2012-12-31":
+            columns = columns.astype("datetime64[ns]")
+        else:
+            assert columns.dtype == object
+
+        expected = DataFrame(
+            [["A", 1, 2], ["B", 3, 4]],
+            columns=columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_range(self):
+        # GH#12071
+        df = DataFrame([[0, 0], [1, 1]], columns=["A", "B"], index=RangeIndex(stop=2))
+        result = df.reset_index()
+        assert isinstance(result.index, RangeIndex)
+        expected = DataFrame(
+            [[0, 0, 0], [1, 1, 1]],
+            columns=["index", "A", "B"],
+            index=RangeIndex(stop=2),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_multiindex_columns(self, multiindex_df):
+        result = multiindex_df[["B"]].rename_axis("A").reset_index()
+        tm.assert_frame_equal(result, multiindex_df)
+
+        # GH#16120: already existing column
+        msg = r"cannot insert \('A', ''\), already exists"
+        with pytest.raises(ValueError, match=msg):
+            multiindex_df.rename_axis("A").reset_index()
+
+        # GH#16164: multiindex (tuple) full key
+        result = multiindex_df.set_index([("A", "")]).reset_index()
+        tm.assert_frame_equal(result, multiindex_df)
+
+        # with additional (unnamed) index level
+        idx_col = DataFrame(
+            [[0], [1]], columns=MultiIndex.from_tuples([("level_0", "")])
+        )
+        expected = pd.concat([idx_col, multiindex_df[[("B", "b"), ("A", "")]]], axis=1)
+        result = multiindex_df.set_index([("B", "b")], append=True).reset_index()
+        tm.assert_frame_equal(result, expected)
+
+        # with index name which is a too long tuple...
+        msg = "Item must have length equal to number of levels."
+        with pytest.raises(ValueError, match=msg):
+            multiindex_df.rename_axis([("C", "c", "i")]).reset_index()
+
+        # or too short...
+        levels = [["A", "a", ""], ["B", "b", "i"]]
+        df2 = DataFrame([[0, 2], [1, 3]], columns=MultiIndex.from_tuples(levels))
+        idx_col = DataFrame(
+            [[0], [1]], columns=MultiIndex.from_tuples([("C", "c", "ii")])
+        )
+        expected = pd.concat([idx_col, df2], axis=1)
+        result = df2.rename_axis([("C", "c")]).reset_index(col_fill="ii")
+        tm.assert_frame_equal(result, expected)
+
+        # ... which is incompatible with col_fill=None
+        with pytest.raises(
+            ValueError,
+            match=(
+                "col_fill=None is incompatible with "
+                r"incomplete column name \('C', 'c'\)"
+            ),
+        ):
+            df2.rename_axis([("C", "c")]).reset_index(col_fill=None)
+
+        # with col_level != 0
+        result = df2.rename_axis([("c", "ii")]).reset_index(col_level=1, col_fill="C")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("flag", [False, True])
+    @pytest.mark.parametrize("allow_duplicates", [False, True])
+    def test_reset_index_duplicate_columns_allow(
+        self, multiindex_df, flag, allow_duplicates
+    ):
+        # GH#44755 reset_index with duplicate column labels
+        df = multiindex_df.rename_axis("A")
+        df = df.set_flags(allows_duplicate_labels=flag)
+
+        if flag and allow_duplicates:
+            result = df.reset_index(allow_duplicates=allow_duplicates)
+            levels = [["A", ""], ["A", ""], ["B", "b"]]
+            expected = DataFrame(
+                [[0, 0, 2], [1, 1, 3]], columns=MultiIndex.from_tuples(levels)
+            )
+            tm.assert_frame_equal(result, expected)
+        else:
+            if not flag and allow_duplicates:
+                msg = (
+                    "Cannot specify 'allow_duplicates=True' when "
+                    "'self.flags.allows_duplicate_labels' is False"
+                )
+            else:
+                msg = r"cannot insert \('A', ''\), already exists"
+            with pytest.raises(ValueError, match=msg):
+                df.reset_index(allow_duplicates=allow_duplicates)
+
+    @pytest.mark.parametrize("flag", [False, True])
+    def test_reset_index_duplicate_columns_default(self, multiindex_df, flag):
+        df = multiindex_df.rename_axis("A")
+        df = df.set_flags(allows_duplicate_labels=flag)
+
+        msg = r"cannot insert \('A', ''\), already exists"
+        with pytest.raises(ValueError, match=msg):
+            df.reset_index()
+
+    @pytest.mark.parametrize("allow_duplicates", ["bad value"])
+    def test_reset_index_allow_duplicates_check(self, multiindex_df, allow_duplicates):
+        with pytest.raises(ValueError, match="expected type bool"):
+            multiindex_df.reset_index(allow_duplicates=allow_duplicates)
+
+    def test_reset_index_datetime(self, tz_naive_fixture):
+        # GH#3950
+        tz = tz_naive_fixture
+        idx1 = date_range("1/1/2011", periods=5, freq="D", tz=tz, name="idx1")
+        idx2 = Index(range(5), name="idx2", dtype="int64")
+        idx = MultiIndex.from_arrays([idx1, idx2])
+        df = DataFrame(
+            {"a": np.arange(5, dtype="int64"), "b": ["A", "B", "C", "D", "E"]},
+            index=idx,
+        )
+
+        expected = DataFrame(
+            {
+                "idx1": [
+                    datetime(2011, 1, 1),
+                    datetime(2011, 1, 2),
+                    datetime(2011, 1, 3),
+                    datetime(2011, 1, 4),
+                    datetime(2011, 1, 5),
+                ],
+                "idx2": np.arange(5, dtype="int64"),
+                "a": np.arange(5, dtype="int64"),
+                "b": ["A", "B", "C", "D", "E"],
+            },
+            columns=["idx1", "idx2", "a", "b"],
+        )
+        expected["idx1"] = expected["idx1"].apply(lambda d: Timestamp(d, tz=tz))
+
+        tm.assert_frame_equal(df.reset_index(), expected)
+
+        idx3 = date_range(
+            "1/1/2012", periods=5, freq="MS", tz="Europe/Paris", name="idx3"
+        )
+        idx = MultiIndex.from_arrays([idx1, idx2, idx3])
+        df = DataFrame(
+            {"a": np.arange(5, dtype="int64"), "b": ["A", "B", "C", "D", "E"]},
+            index=idx,
+        )
+
+        expected = DataFrame(
+            {
+                "idx1": [
+                    datetime(2011, 1, 1),
+                    datetime(2011, 1, 2),
+                    datetime(2011, 1, 3),
+                    datetime(2011, 1, 4),
+                    datetime(2011, 1, 5),
+                ],
+                "idx2": np.arange(5, dtype="int64"),
+                "idx3": [
+                    datetime(2012, 1, 1),
+                    datetime(2012, 2, 1),
+                    datetime(2012, 3, 1),
+                    datetime(2012, 4, 1),
+                    datetime(2012, 5, 1),
+                ],
+                "a": np.arange(5, dtype="int64"),
+                "b": ["A", "B", "C", "D", "E"],
+            },
+            columns=["idx1", "idx2", "idx3", "a", "b"],
+        )
+        expected["idx1"] = expected["idx1"].apply(lambda d: Timestamp(d, tz=tz))
+        expected["idx3"] = expected["idx3"].apply(
+            lambda d: Timestamp(d, tz="Europe/Paris")
+        )
+        tm.assert_frame_equal(df.reset_index(), expected)
+
+        # GH#7793
+        idx = MultiIndex.from_product(
+            [["a", "b"], date_range("20130101", periods=3, tz=tz)]
+        )
+        df = DataFrame(
+            np.arange(6, dtype="int64").reshape(6, 1), columns=["a"], index=idx
+        )
+
+        expected = DataFrame(
+            {
+                "level_0": "a a a b b b".split(),
+                "level_1": [
+                    datetime(2013, 1, 1),
+                    datetime(2013, 1, 2),
+                    datetime(2013, 1, 3),
+                ]
+                * 2,
+                "a": np.arange(6, dtype="int64"),
+            },
+            columns=["level_0", "level_1", "a"],
+        )
+        expected["level_1"] = expected["level_1"].apply(lambda d: Timestamp(d, tz=tz))
+        result = df.reset_index()
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_period(self):
+        # GH#7746
+        idx = MultiIndex.from_product(
+            [pd.period_range("20130101", periods=3, freq="M"), list("abc")],
+            names=["month", "feature"],
+        )
+
+        df = DataFrame(
+            np.arange(9, dtype="int64").reshape(-1, 1), index=idx, columns=["a"]
+        )
+        expected = DataFrame(
+            {
+                "month": (
+                    [pd.Period("2013-01", freq="M")] * 3
+                    + [pd.Period("2013-02", freq="M")] * 3
+                    + [pd.Period("2013-03", freq="M")] * 3
+                ),
+                "feature": ["a", "b", "c"] * 3,
+                "a": np.arange(9, dtype="int64"),
+            },
+            columns=["month", "feature", "a"],
+        )
+        result = df.reset_index()
+        tm.assert_frame_equal(result, expected)
+
+    def test_reset_index_delevel_infer_dtype(self):
+        tuples = list(product(["foo", "bar"], [10, 20], [1.0, 1.1]))
+        index = MultiIndex.from_tuples(tuples, names=["prm0", "prm1", "prm2"])
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((8, 3)),
+            columns=["A", "B", "C"],
+            index=index,
+        )
+        deleveled = df.reset_index()
+        assert is_integer_dtype(deleveled["prm1"])
+        assert is_float_dtype(deleveled["prm2"])
+
+    def test_reset_index_with_drop(
+        self, multiindex_year_month_day_dataframe_random_data
+    ):
+        ymd = multiindex_year_month_day_dataframe_random_data
+
+        deleveled = ymd.reset_index(drop=True)
+        assert len(deleveled.columns) == len(ymd.columns)
+        assert deleveled.index.name == ymd.index.name
+
+    @pytest.mark.parametrize(
+        "ix_data, exp_data",
+        [
+            (
+                [(pd.NaT, 1), (pd.NaT, 2)],
+                {"a": [pd.NaT, pd.NaT], "b": [1, 2], "x": [11, 12]},
+            ),
+            (
+                [(pd.NaT, 1), (Timestamp("2020-01-01"), 2)],
+                {"a": [pd.NaT, Timestamp("2020-01-01")], "b": [1, 2], "x": [11, 12]},
+            ),
+            (
+                [(pd.NaT, 1), (pd.Timedelta(123, "d"), 2)],
+                {"a": [pd.NaT, pd.Timedelta(123, "d")], "b": [1, 2], "x": [11, 12]},
+            ),
+        ],
+    )
+    def test_reset_index_nat_multiindex(self, ix_data, exp_data):
+        # GH#36541: that reset_index() does not raise ValueError
+        ix = MultiIndex.from_tuples(ix_data, names=["a", "b"])
+        result = DataFrame({"x": [11, 12]}, index=ix)
+        result = result.reset_index()
+
+        expected = DataFrame(exp_data)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "codes", ([[0, 0, 1, 1], [0, 1, 0, 1]], [[0, 0, -1, 1], [0, 1, 0, 1]])
+    )
+    def test_rest_index_multiindex_categorical_with_missing_values(self, codes):
+        # GH#24206
+
+        index = MultiIndex(
+            [CategoricalIndex(["A", "B"]), CategoricalIndex(["a", "b"])], codes
+        )
+        data = {"col": range(len(index))}
+        df = DataFrame(data=data, index=index)
+
+        expected = DataFrame(
+            {
+                "level_0": Categorical.from_codes(codes[0], categories=["A", "B"]),
+                "level_1": Categorical.from_codes(codes[1], categories=["a", "b"]),
+                "col": range(4),
+            }
+        )
+
+        res = df.reset_index()
+        tm.assert_frame_equal(res, expected)
+
+        # roundtrip
+        res = expected.set_index(["level_0", "level_1"]).reset_index()
+        tm.assert_frame_equal(res, expected)
+
+
+@pytest.mark.parametrize(
+    "array, dtype",
+    [
+        (["a", "b"], object),
+        (
+            pd.period_range("12-1-2000", periods=2, freq="Q-DEC"),
+            pd.PeriodDtype(freq="Q-DEC"),
+        ),
+    ],
+)
+def test_reset_index_dtypes_on_empty_frame_with_multiindex(array, dtype):
+    # GH 19602 - Preserve dtype on empty DataFrame with MultiIndex
+    idx = MultiIndex.from_product([[0, 1], [0.5, 1.0], array])
+    result = DataFrame(index=idx)[:0].reset_index().dtypes
+    expected = Series({"level_0": np.int64, "level_1": np.float64, "level_2": dtype})
+    tm.assert_series_equal(result, expected)
+
+
+def test_reset_index_empty_frame_with_datetime64_multiindex():
+    # https://github.com/pandas-dev/pandas/issues/35606
+    idx = MultiIndex(
+        levels=[[Timestamp("2020-07-20 00:00:00")], [3, 4]],
+        codes=[[], []],
+        names=["a", "b"],
+    )
+    df = DataFrame(index=idx, columns=["c", "d"])
+    result = df.reset_index()
+    expected = DataFrame(
+        columns=list("abcd"), index=RangeIndex(start=0, stop=0, step=1)
+    )
+    expected["a"] = expected["a"].astype("datetime64[ns]")
+    expected["b"] = expected["b"].astype("int64")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_empty_frame_with_datetime64_multiindex_from_groupby():
+    # https://github.com/pandas-dev/pandas/issues/35657
+    df = DataFrame({"c1": [10.0], "c2": ["a"], "c3": pd.to_datetime("2020-01-01")})
+    df = df.head(0).groupby(["c2", "c3"])[["c1"]].sum()
+    result = df.reset_index()
+    expected = DataFrame(
+        columns=["c2", "c3", "c1"], index=RangeIndex(start=0, stop=0, step=1)
+    )
+    expected["c3"] = expected["c3"].astype("datetime64[ns]")
+    expected["c1"] = expected["c1"].astype("float64")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_multiindex_nat():
+    # GH 11479
+    idx = range(3)
+    tstamp = date_range("2015-07-01", freq="D", periods=3)
+    df = DataFrame({"id": idx, "tstamp": tstamp, "a": list("abc")})
+    df.loc[2, "tstamp"] = pd.NaT
+    result = df.set_index(["id", "tstamp"]).reset_index("id")
+    expected = DataFrame(
+        {"id": range(3), "a": list("abc")},
+        index=pd.DatetimeIndex(["2015-07-01", "2015-07-02", "NaT"], name="tstamp"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_interval_columns_object_cast():
+    # GH 19136
+    df = DataFrame(
+        np.eye(2), index=Index([1, 2], name="Year"), columns=cut([1, 2], [0, 1, 2])
+    )
+    result = df.reset_index()
+    expected = DataFrame(
+        [[1, 1.0, 0.0], [2, 0.0, 1.0]],
+        columns=Index(["Year", Interval(0, 1), Interval(1, 2)]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_reset_index_rename(float_frame):
+    # GH 6878
+    result = float_frame.reset_index(names="new_name")
+    expected = Series(float_frame.index.values, name="new_name")
+    tm.assert_series_equal(result["new_name"], expected)
+
+    result = float_frame.reset_index(names=123)
+    expected = Series(float_frame.index.values, name=123)
+    tm.assert_series_equal(result[123], expected)
+
+
+def test_reset_index_rename_multiindex(float_frame):
+    # GH 6878
+    stacked_df = float_frame.stack(future_stack=True)[::2]
+    stacked_df = DataFrame({"foo": stacked_df, "bar": stacked_df})
+
+    names = ["first", "second"]
+    stacked_df.index.names = names
+
+    result = stacked_df.reset_index()
+    expected = stacked_df.reset_index(names=["new_first", "new_second"])
+    tm.assert_series_equal(result["first"], expected["new_first"], check_names=False)
+    tm.assert_series_equal(result["second"], expected["new_second"], check_names=False)
+
+
+def test_errorreset_index_rename(float_frame):
+    # GH 6878
+    stacked_df = float_frame.stack(future_stack=True)[::2]
+    stacked_df = DataFrame({"first": stacked_df, "second": stacked_df})
+
+    with pytest.raises(
+        ValueError, match="Index names must be str or 1-dimensional list"
+    ):
+        stacked_df.reset_index(names={"first": "new_first", "second": "new_second"})
+
+    with pytest.raises(IndexError, match="list index out of range"):
+        stacked_df.reset_index(names=["new_first"])
+
+
+def test_reset_index_false_index_name():
+    result_series = Series(data=range(5, 10), index=range(0, 5))
+    result_series.index.name = False
+    result_series.reset_index()
+    expected_series = Series(range(5, 10), RangeIndex(range(0, 5), name=False))
+    tm.assert_series_equal(result_series, expected_series)
+
+    # GH 38147
+    result_frame = DataFrame(data=range(5, 10), index=range(0, 5))
+    result_frame.index.name = False
+    result_frame.reset_index()
+    expected_frame = DataFrame(range(5, 10), RangeIndex(range(0, 5), name=False))
+    tm.assert_frame_equal(result_frame, expected_frame)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_round.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_round.py
new file mode 100644
index 0000000000000000000000000000000000000000..a96df27b48d7d8dc0b2f26cc25f0dca16ea3b462
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_round.py
@@ -0,0 +1,225 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameRound:
+    def test_round(self):
+        # GH#2665
+
+        # Test that rounding an empty DataFrame does nothing
+        df = DataFrame()
+        tm.assert_frame_equal(df, df.round())
+
+        # Here's the test frame we'll be working with
+        df = DataFrame({"col1": [1.123, 2.123, 3.123], "col2": [1.234, 2.234, 3.234]})
+
+        # Default round to integer (i.e. decimals=0)
+        expected_rounded = DataFrame({"col1": [1.0, 2.0, 3.0], "col2": [1.0, 2.0, 3.0]})
+        tm.assert_frame_equal(df.round(), expected_rounded)
+
+        # Round with an integer
+        decimals = 2
+        expected_rounded = DataFrame(
+            {"col1": [1.12, 2.12, 3.12], "col2": [1.23, 2.23, 3.23]}
+        )
+        tm.assert_frame_equal(df.round(decimals), expected_rounded)
+
+        # This should also work with np.round (since np.round dispatches to
+        # df.round)
+        tm.assert_frame_equal(np.round(df, decimals), expected_rounded)
+
+        # Round with a list
+        round_list = [1, 2]
+        msg = "decimals must be an integer, a dict-like or a Series"
+        with pytest.raises(TypeError, match=msg):
+            df.round(round_list)
+
+        # Round with a dictionary
+        expected_rounded = DataFrame(
+            {"col1": [1.1, 2.1, 3.1], "col2": [1.23, 2.23, 3.23]}
+        )
+        round_dict = {"col1": 1, "col2": 2}
+        tm.assert_frame_equal(df.round(round_dict), expected_rounded)
+
+        # Incomplete dict
+        expected_partially_rounded = DataFrame(
+            {"col1": [1.123, 2.123, 3.123], "col2": [1.2, 2.2, 3.2]}
+        )
+        partial_round_dict = {"col2": 1}
+        tm.assert_frame_equal(df.round(partial_round_dict), expected_partially_rounded)
+
+        # Dict with unknown elements
+        wrong_round_dict = {"col3": 2, "col2": 1}
+        tm.assert_frame_equal(df.round(wrong_round_dict), expected_partially_rounded)
+
+        # float input to `decimals`
+        non_int_round_dict = {"col1": 1, "col2": 0.5}
+        msg = "Values in decimals must be integers"
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_dict)
+
+        # String input
+        non_int_round_dict = {"col1": 1, "col2": "foo"}
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_dict)
+
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_Series)
+
+        # List input
+        non_int_round_dict = {"col1": 1, "col2": [1, 2]}
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_dict)
+
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_Series)
+
+        # Non integer Series inputs
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_Series)
+
+        non_int_round_Series = Series(non_int_round_dict)
+        with pytest.raises(TypeError, match=msg):
+            df.round(non_int_round_Series)
+
+        # Negative numbers
+        negative_round_dict = {"col1": -1, "col2": -2}
+        big_df = df * 100
+        expected_neg_rounded = DataFrame(
+            {"col1": [110.0, 210, 310], "col2": [100.0, 200, 300]}
+        )
+        tm.assert_frame_equal(big_df.round(negative_round_dict), expected_neg_rounded)
+
+        # nan in Series round
+        nan_round_Series = Series({"col1": np.nan, "col2": 1})
+
+        with pytest.raises(TypeError, match=msg):
+            df.round(nan_round_Series)
+
+        # Make sure this doesn't break existing Series.round
+        tm.assert_series_equal(df["col1"].round(1), expected_rounded["col1"])
+
+        # named columns
+        # GH#11986
+        decimals = 2
+        expected_rounded = DataFrame(
+            {"col1": [1.12, 2.12, 3.12], "col2": [1.23, 2.23, 3.23]}
+        )
+        df.columns.name = "cols"
+        expected_rounded.columns.name = "cols"
+        tm.assert_frame_equal(df.round(decimals), expected_rounded)
+
+        # interaction of named columns & series
+        tm.assert_series_equal(df["col1"].round(decimals), expected_rounded["col1"])
+        tm.assert_series_equal(df.round(decimals)["col1"], expected_rounded["col1"])
+
+    def test_round_numpy(self):
+        # GH#12600
+        df = DataFrame([[1.53, 1.36], [0.06, 7.01]])
+        out = np.round(df, decimals=0)
+        expected = DataFrame([[2.0, 1.0], [0.0, 7.0]])
+        tm.assert_frame_equal(out, expected)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.round(df, decimals=0, out=df)
+
+    def test_round_numpy_with_nan(self):
+        # See GH#14197
+        df = Series([1.53, np.nan, 0.06]).to_frame()
+        with tm.assert_produces_warning(None):
+            result = df.round()
+        expected = Series([2.0, np.nan, 0.0]).to_frame()
+        tm.assert_frame_equal(result, expected)
+
+    def test_round_mixed_type(self):
+        # GH#11885
+        df = DataFrame(
+            {
+                "col1": [1.1, 2.2, 3.3, 4.4],
+                "col2": ["1", "a", "c", "f"],
+                "col3": date_range("20111111", periods=4),
+            }
+        )
+        round_0 = DataFrame(
+            {
+                "col1": [1.0, 2.0, 3.0, 4.0],
+                "col2": ["1", "a", "c", "f"],
+                "col3": date_range("20111111", periods=4),
+            }
+        )
+        tm.assert_frame_equal(df.round(), round_0)
+        tm.assert_frame_equal(df.round(1), df)
+        tm.assert_frame_equal(df.round({"col1": 1}), df)
+        tm.assert_frame_equal(df.round({"col1": 0}), round_0)
+        tm.assert_frame_equal(df.round({"col1": 0, "col2": 1}), round_0)
+        tm.assert_frame_equal(df.round({"col3": 1}), df)
+
+    def test_round_with_duplicate_columns(self):
+        # GH#11611
+
+        df = DataFrame(
+            np.random.default_rng(2).random([3, 3]),
+            columns=["A", "B", "C"],
+            index=["first", "second", "third"],
+        )
+
+        dfs = pd.concat((df, df), axis=1)
+        rounded = dfs.round()
+        tm.assert_index_equal(rounded.index, dfs.index)
+
+        decimals = Series([1, 0, 2], index=["A", "B", "A"])
+        msg = "Index of decimals must be unique"
+        with pytest.raises(ValueError, match=msg):
+            df.round(decimals)
+
+    def test_round_builtin(self):
+        # GH#11763
+        # Here's the test frame we'll be working with
+        df = DataFrame({"col1": [1.123, 2.123, 3.123], "col2": [1.234, 2.234, 3.234]})
+
+        # Default round to integer (i.e. decimals=0)
+        expected_rounded = DataFrame({"col1": [1.0, 2.0, 3.0], "col2": [1.0, 2.0, 3.0]})
+        tm.assert_frame_equal(round(df), expected_rounded)
+
+    def test_round_nonunique_categorical(self):
+        # See GH#21809
+        idx = pd.CategoricalIndex(["low"] * 3 + ["hi"] * 3)
+        df = DataFrame(np.random.default_rng(2).random((6, 3)), columns=list("abc"))
+
+        expected = df.round(3)
+        expected.index = idx
+
+        df_categorical = df.copy().set_index(idx)
+        assert df_categorical.shape == (6, 3)
+        result = df_categorical.round(3)
+        assert result.shape == (6, 3)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_round_interval_category_columns(self):
+        # GH#30063
+        columns = pd.CategoricalIndex(pd.interval_range(0, 2))
+        df = DataFrame([[0.66, 1.1], [0.3, 0.25]], columns=columns)
+
+        result = df.round()
+        expected = DataFrame([[1.0, 1.0], [0.0, 0.0]], columns=columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_round_empty_not_input(self):
+        # GH#51032
+        df = DataFrame()
+        result = df.round()
+        tm.assert_frame_equal(df, result)
+        assert df is not result
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sample.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sample.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b3459fbdc0359c4d234dd9d1f3c2bbfbcb5c260
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sample.py
@@ -0,0 +1,372 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+import pandas.core.common as com
+
+
+class TestSample:
+    @pytest.fixture
+    def obj(self, frame_or_series):
+        if frame_or_series is Series:
+            arr = np.random.default_rng(2).standard_normal(10)
+        else:
+            arr = np.random.default_rng(2).standard_normal((10, 10))
+        return frame_or_series(arr, dtype=None)
+
+    @pytest.mark.parametrize("test", list(range(10)))
+    def test_sample(self, test, obj):
+        # Fixes issue: 2419
+        # Check behavior of random_state argument
+        # Check for stability when receives seed or random state -- run 10
+        # times.
+
+        seed = np.random.default_rng(2).integers(0, 100)
+        tm.assert_equal(
+            obj.sample(n=4, random_state=seed), obj.sample(n=4, random_state=seed)
+        )
+
+        tm.assert_equal(
+            obj.sample(frac=0.7, random_state=seed),
+            obj.sample(frac=0.7, random_state=seed),
+        )
+
+        tm.assert_equal(
+            obj.sample(n=4, random_state=np.random.default_rng(test)),
+            obj.sample(n=4, random_state=np.random.default_rng(test)),
+        )
+
+        tm.assert_equal(
+            obj.sample(frac=0.7, random_state=np.random.default_rng(test)),
+            obj.sample(frac=0.7, random_state=np.random.default_rng(test)),
+        )
+
+        tm.assert_equal(
+            obj.sample(
+                frac=2,
+                replace=True,
+                random_state=np.random.default_rng(test),
+            ),
+            obj.sample(
+                frac=2,
+                replace=True,
+                random_state=np.random.default_rng(test),
+            ),
+        )
+
+        os1, os2 = [], []
+        for _ in range(2):
+            os1.append(obj.sample(n=4, random_state=test))
+            os2.append(obj.sample(frac=0.7, random_state=test))
+        tm.assert_equal(*os1)
+        tm.assert_equal(*os2)
+
+    def test_sample_lengths(self, obj):
+        # Check lengths are right
+        assert len(obj.sample(n=4) == 4)
+        assert len(obj.sample(frac=0.34) == 3)
+        assert len(obj.sample(frac=0.36) == 4)
+
+    def test_sample_invalid_random_state(self, obj):
+        # Check for error when random_state argument invalid.
+        msg = (
+            "random_state must be an integer, array-like, a BitGenerator, Generator, "
+            "a numpy RandomState, or None"
+        )
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(random_state="a_string")
+
+    def test_sample_wont_accept_n_and_frac(self, obj):
+        # Giving both frac and N throws error
+        msg = "Please enter a value for `frac` OR `n`, not both"
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(n=3, frac=0.3)
+
+    def test_sample_requires_positive_n_frac(self, obj):
+        with pytest.raises(
+            ValueError,
+            match="A negative number of rows requested. Please provide `n` >= 0",
+        ):
+            obj.sample(n=-3)
+        with pytest.raises(
+            ValueError,
+            match="A negative number of rows requested. Please provide `frac` >= 0",
+        ):
+            obj.sample(frac=-0.3)
+
+    def test_sample_requires_integer_n(self, obj):
+        # Make sure float values of `n` give error
+        with pytest.raises(ValueError, match="Only integers accepted as `n` values"):
+            obj.sample(n=3.2)
+
+    def test_sample_invalid_weight_lengths(self, obj):
+        # Weight length must be right
+        msg = "Weights and axis to be sampled must be of same length"
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(n=3, weights=[0, 1])
+
+        with pytest.raises(ValueError, match=msg):
+            bad_weights = [0.5] * 11
+            obj.sample(n=3, weights=bad_weights)
+
+        with pytest.raises(ValueError, match="Fewer non-zero entries in p than size"):
+            bad_weight_series = Series([0, 0, 0.2])
+            obj.sample(n=4, weights=bad_weight_series)
+
+    def test_sample_negative_weights(self, obj):
+        # Check won't accept negative weights
+        bad_weights = [-0.1] * 10
+        msg = "weight vector many not include negative values"
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(n=3, weights=bad_weights)
+
+    def test_sample_inf_weights(self, obj):
+        # Check inf and -inf throw errors:
+
+        weights_with_inf = [0.1] * 10
+        weights_with_inf[0] = np.inf
+        msg = "weight vector may not include `inf` values"
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(n=3, weights=weights_with_inf)
+
+        weights_with_ninf = [0.1] * 10
+        weights_with_ninf[0] = -np.inf
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(n=3, weights=weights_with_ninf)
+
+    def test_sample_zero_weights(self, obj):
+        # All zeros raises errors
+
+        zero_weights = [0] * 10
+        with pytest.raises(ValueError, match="Invalid weights: weights sum to zero"):
+            obj.sample(n=3, weights=zero_weights)
+
+    def test_sample_missing_weights(self, obj):
+        # All missing weights
+
+        nan_weights = [np.nan] * 10
+        with pytest.raises(ValueError, match="Invalid weights: weights sum to zero"):
+            obj.sample(n=3, weights=nan_weights)
+
+    def test_sample_none_weights(self, obj):
+        # Check None are also replaced by zeros.
+        weights_with_None = [None] * 10
+        weights_with_None[5] = 0.5
+        tm.assert_equal(
+            obj.sample(n=1, axis=0, weights=weights_with_None), obj.iloc[5:6]
+        )
+
+    @pytest.mark.parametrize(
+        "func_str,arg",
+        [
+            ("np.array", [2, 3, 1, 0]),
+            ("np.random.MT19937", 3),
+            ("np.random.PCG64", 11),
+        ],
+    )
+    def test_sample_random_state(self, func_str, arg, frame_or_series):
+        # GH#32503
+        obj = DataFrame({"col1": range(10, 20), "col2": range(20, 30)})
+        obj = tm.get_obj(obj, frame_or_series)
+        result = obj.sample(n=3, random_state=eval(func_str)(arg))
+        expected = obj.sample(n=3, random_state=com.random_state(eval(func_str)(arg)))
+        tm.assert_equal(result, expected)
+
+    def test_sample_generator(self, frame_or_series):
+        # GH#38100
+        obj = frame_or_series(np.arange(100))
+        rng = np.random.default_rng(2)
+
+        # Consecutive calls should advance the seed
+        result1 = obj.sample(n=50, random_state=rng)
+        result2 = obj.sample(n=50, random_state=rng)
+        assert not (result1.index.values == result2.index.values).all()
+
+        # Matching generator initialization must give same result
+        # Consecutive calls should advance the seed
+        result1 = obj.sample(n=50, random_state=np.random.default_rng(11))
+        result2 = obj.sample(n=50, random_state=np.random.default_rng(11))
+        tm.assert_equal(result1, result2)
+
+    def test_sample_upsampling_without_replacement(self, frame_or_series):
+        # GH#27451
+
+        obj = DataFrame({"A": list("abc")})
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = (
+            "Replace has to be set to `True` when "
+            "upsampling the population `frac` > 1."
+        )
+        with pytest.raises(ValueError, match=msg):
+            obj.sample(frac=2, replace=False)
+
+
+class TestSampleDataFrame:
+    # Tests which are relevant only for DataFrame, so these are
+    #  as fully parametrized as they can get.
+
+    def test_sample(self):
+        # GH#2419
+        # additional specific object based tests
+
+        # A few dataframe test with degenerate weights.
+        easy_weight_list = [0] * 10
+        easy_weight_list[5] = 1
+
+        df = DataFrame(
+            {
+                "col1": range(10, 20),
+                "col2": range(20, 30),
+                "colString": ["a"] * 10,
+                "easyweights": easy_weight_list,
+            }
+        )
+        sample1 = df.sample(n=1, weights="easyweights")
+        tm.assert_frame_equal(sample1, df.iloc[5:6])
+
+        # Ensure proper error if string given as weight for Series or
+        # DataFrame with axis = 1.
+        ser = Series(range(10))
+        msg = "Strings cannot be passed as weights when sampling from a Series."
+        with pytest.raises(ValueError, match=msg):
+            ser.sample(n=3, weights="weight_column")
+
+        msg = (
+            "Strings can only be passed to weights when sampling from rows on a "
+            "DataFrame"
+        )
+        with pytest.raises(ValueError, match=msg):
+            df.sample(n=1, weights="weight_column", axis=1)
+
+        # Check weighting key error
+        with pytest.raises(
+            KeyError, match="'String passed to weights not a valid column'"
+        ):
+            df.sample(n=3, weights="not_a_real_column_name")
+
+        # Check that re-normalizes weights that don't sum to one.
+        weights_less_than_1 = [0] * 10
+        weights_less_than_1[0] = 0.5
+        tm.assert_frame_equal(df.sample(n=1, weights=weights_less_than_1), df.iloc[:1])
+
+        ###
+        # Test axis argument
+        ###
+
+        # Test axis argument
+        df = DataFrame({"col1": range(10), "col2": ["a"] * 10})
+        second_column_weight = [0, 1]
+        tm.assert_frame_equal(
+            df.sample(n=1, axis=1, weights=second_column_weight), df[["col2"]]
+        )
+
+        # Different axis arg types
+        tm.assert_frame_equal(
+            df.sample(n=1, axis="columns", weights=second_column_weight), df[["col2"]]
+        )
+
+        weight = [0] * 10
+        weight[5] = 0.5
+        tm.assert_frame_equal(df.sample(n=1, axis="rows", weights=weight), df.iloc[5:6])
+        tm.assert_frame_equal(
+            df.sample(n=1, axis="index", weights=weight), df.iloc[5:6]
+        )
+
+        # Check out of range axis values
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.sample(n=1, axis=2)
+
+        msg = "No axis named not_a_name for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.sample(n=1, axis="not_a_name")
+
+        ser = Series(range(10))
+        with pytest.raises(ValueError, match="No axis named 1 for object type Series"):
+            ser.sample(n=1, axis=1)
+
+        # Test weight length compared to correct axis
+        msg = "Weights and axis to be sampled must be of same length"
+        with pytest.raises(ValueError, match=msg):
+            df.sample(n=1, axis=1, weights=[0.5] * 10)
+
+    def test_sample_axis1(self):
+        # Check weights with axis = 1
+        easy_weight_list = [0] * 3
+        easy_weight_list[2] = 1
+
+        df = DataFrame(
+            {"col1": range(10, 20), "col2": range(20, 30), "colString": ["a"] * 10}
+        )
+        sample1 = df.sample(n=1, axis=1, weights=easy_weight_list)
+        tm.assert_frame_equal(sample1, df[["colString"]])
+
+        # Test default axes
+        tm.assert_frame_equal(
+            df.sample(n=3, random_state=42), df.sample(n=3, axis=0, random_state=42)
+        )
+
+    def test_sample_aligns_weights_with_frame(self):
+        # Test that function aligns weights with frame
+        df = DataFrame({"col1": [5, 6, 7], "col2": ["a", "b", "c"]}, index=[9, 5, 3])
+        ser = Series([1, 0, 0], index=[3, 5, 9])
+        tm.assert_frame_equal(df.loc[[3]], df.sample(1, weights=ser))
+
+        # Weights have index values to be dropped because not in
+        # sampled DataFrame
+        ser2 = Series([0.001, 0, 10000], index=[3, 5, 10])
+        tm.assert_frame_equal(df.loc[[3]], df.sample(1, weights=ser2))
+
+        # Weights have empty values to be filed with zeros
+        ser3 = Series([0.01, 0], index=[3, 5])
+        tm.assert_frame_equal(df.loc[[3]], df.sample(1, weights=ser3))
+
+        # No overlap in weight and sampled DataFrame indices
+        ser4 = Series([1, 0], index=[1, 2])
+
+        with pytest.raises(ValueError, match="Invalid weights: weights sum to zero"):
+            df.sample(1, weights=ser4)
+
+    def test_sample_is_copy(self):
+        # GH#27357, GH#30784: ensure the result of sample is an actual copy and
+        # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)), columns=["a", "b", "c"]
+        )
+        df2 = df.sample(3)
+
+        with tm.assert_produces_warning(None):
+            df2["d"] = 1
+
+    def test_sample_does_not_modify_weights(self):
+        # GH-42843
+        result = np.array([np.nan, 1, np.nan])
+        expected = result.copy()
+        ser = Series([1, 2, 3])
+
+        # Test numpy array weights won't be modified in place
+        ser.sample(weights=result)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # Test DataFrame column won't be modified in place
+        df = DataFrame({"values": [1, 1, 1], "weights": [1, np.nan, np.nan]})
+        expected = df["weights"].copy()
+
+        df.sample(frac=1.0, replace=True, weights="weights")
+        result = df["weights"]
+        tm.assert_series_equal(result, expected)
+
+    def test_sample_ignore_index(self):
+        # GH 38581
+        df = DataFrame(
+            {"col1": range(10, 20), "col2": range(20, 30), "colString": ["a"] * 10}
+        )
+        result = df.sample(3, ignore_index=True)
+        expected_index = Index(range(3))
+        tm.assert_index_equal(result.index, expected_index, exact=True)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_select_dtypes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_select_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..a38d2c6fd016ad197178887d638be9a84f58e8de
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_select_dtypes.py
@@ -0,0 +1,466 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import ExtensionDtype
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.arrays import ExtensionArray
+
+
+class DummyDtype(ExtensionDtype):
+    type = int
+
+    def __init__(self, numeric) -> None:
+        self._numeric = numeric
+
+    @property
+    def name(self):
+        return "Dummy"
+
+    @property
+    def _is_numeric(self):
+        return self._numeric
+
+
+class DummyArray(ExtensionArray):
+    def __init__(self, data, dtype) -> None:
+        self.data = data
+        self._dtype = dtype
+
+    def __array__(self, dtype):
+        return self.data
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, item):
+        pass
+
+    def copy(self):
+        return self
+
+
+class TestSelectDtypes:
+    def test_select_dtypes_include_using_list_like(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.Categorical(list("abc")),
+                "g": pd.date_range("20130101", periods=3),
+                "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+                "i": pd.date_range("20130101", periods=3, tz="CET"),
+                "j": pd.period_range("2013-01", periods=3, freq="M"),
+                "k": pd.timedelta_range("1 day", periods=3),
+            }
+        )
+
+        ri = df.select_dtypes(include=[np.number])
+        ei = df[["b", "c", "d", "k"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include=[np.number], exclude=["timedelta"])
+        ei = df[["b", "c", "d"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include=[np.number, "category"], exclude=["timedelta"])
+        ei = df[["b", "c", "d", "f"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include=["datetime"])
+        ei = df[["g"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include=["datetime64"])
+        ei = df[["g"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include=["datetimetz"])
+        ei = df[["h", "i"]]
+        tm.assert_frame_equal(ri, ei)
+
+        with pytest.raises(NotImplementedError, match=r"^$"):
+            df.select_dtypes(include=["period"])
+
+    def test_select_dtypes_exclude_using_list_like(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+            }
+        )
+        re = df.select_dtypes(exclude=[np.number])
+        ee = df[["a", "e"]]
+        tm.assert_frame_equal(re, ee)
+
+    def test_select_dtypes_exclude_include_using_list_like(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6, dtype="u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+        exclude = (np.datetime64,)
+        include = np.bool_, "integer"
+        r = df.select_dtypes(include=include, exclude=exclude)
+        e = df[["b", "c", "e"]]
+        tm.assert_frame_equal(r, e)
+
+        exclude = ("datetime",)
+        include = "bool", "int64", "int32"
+        r = df.select_dtypes(include=include, exclude=exclude)
+        e = df[["b", "e"]]
+        tm.assert_frame_equal(r, e)
+
+    @pytest.mark.parametrize(
+        "include", [(np.bool_, "int"), (np.bool_, "integer"), ("bool", int)]
+    )
+    def test_select_dtypes_exclude_include_int(self, include):
+        # Fix select_dtypes(include='int') for Windows, FYI #36596
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6, dtype="int32"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+        exclude = (np.datetime64,)
+        result = df.select_dtypes(include=include, exclude=exclude)
+        expected = df[["b", "c", "e"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_select_dtypes_include_using_scalars(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.Categorical(list("abc")),
+                "g": pd.date_range("20130101", periods=3),
+                "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+                "i": pd.date_range("20130101", periods=3, tz="CET"),
+                "j": pd.period_range("2013-01", periods=3, freq="M"),
+                "k": pd.timedelta_range("1 day", periods=3),
+            }
+        )
+
+        ri = df.select_dtypes(include=np.number)
+        ei = df[["b", "c", "d", "k"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include="datetime")
+        ei = df[["g"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include="datetime64")
+        ei = df[["g"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include="category")
+        ei = df[["f"]]
+        tm.assert_frame_equal(ri, ei)
+
+        with pytest.raises(NotImplementedError, match=r"^$"):
+            df.select_dtypes(include="period")
+
+    def test_select_dtypes_exclude_using_scalars(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.Categorical(list("abc")),
+                "g": pd.date_range("20130101", periods=3),
+                "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+                "i": pd.date_range("20130101", periods=3, tz="CET"),
+                "j": pd.period_range("2013-01", periods=3, freq="M"),
+                "k": pd.timedelta_range("1 day", periods=3),
+            }
+        )
+
+        ri = df.select_dtypes(exclude=np.number)
+        ei = df[["a", "e", "f", "g", "h", "i", "j"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(exclude="category")
+        ei = df[["a", "b", "c", "d", "e", "g", "h", "i", "j", "k"]]
+        tm.assert_frame_equal(ri, ei)
+
+        with pytest.raises(NotImplementedError, match=r"^$"):
+            df.select_dtypes(exclude="period")
+
+    def test_select_dtypes_include_exclude_using_scalars(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.Categorical(list("abc")),
+                "g": pd.date_range("20130101", periods=3),
+                "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+                "i": pd.date_range("20130101", periods=3, tz="CET"),
+                "j": pd.period_range("2013-01", periods=3, freq="M"),
+                "k": pd.timedelta_range("1 day", periods=3),
+            }
+        )
+
+        ri = df.select_dtypes(include=np.number, exclude="floating")
+        ei = df[["b", "c", "k"]]
+        tm.assert_frame_equal(ri, ei)
+
+    def test_select_dtypes_include_exclude_mixed_scalars_lists(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.Categorical(list("abc")),
+                "g": pd.date_range("20130101", periods=3),
+                "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+                "i": pd.date_range("20130101", periods=3, tz="CET"),
+                "j": pd.period_range("2013-01", periods=3, freq="M"),
+                "k": pd.timedelta_range("1 day", periods=3),
+            }
+        )
+
+        ri = df.select_dtypes(include=np.number, exclude=["floating", "timedelta"])
+        ei = df[["b", "c"]]
+        tm.assert_frame_equal(ri, ei)
+
+        ri = df.select_dtypes(include=[np.number, "category"], exclude="floating")
+        ei = df[["b", "c", "f", "k"]]
+        tm.assert_frame_equal(ri, ei)
+
+    def test_select_dtypes_duplicate_columns(self):
+        # GH20839
+        df = DataFrame(
+            {
+                "a": ["a", "b", "c"],
+                "b": [1, 2, 3],
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+        df.columns = ["a", "a", "b", "b", "b", "c"]
+
+        expected = DataFrame(
+            {"a": list(range(1, 4)), "b": np.arange(3, 6).astype("u1")}
+        )
+
+        result = df.select_dtypes(include=[np.number], exclude=["floating"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_select_dtypes_not_an_attr_but_still_valid_dtype(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+        df["g"] = df.f.diff()
+        assert not hasattr(np, "u8")
+        r = df.select_dtypes(include=["i8", "O"], exclude=["timedelta"])
+        e = df[["a", "b"]]
+        tm.assert_frame_equal(r, e)
+
+        r = df.select_dtypes(include=["i8", "O", "timedelta64[ns]"])
+        e = df[["a", "b", "g"]]
+        tm.assert_frame_equal(r, e)
+
+    def test_select_dtypes_empty(self):
+        df = DataFrame({"a": list("abc"), "b": list(range(1, 4))})
+        msg = "at least one of include or exclude must be nonempty"
+        with pytest.raises(ValueError, match=msg):
+            df.select_dtypes()
+
+    def test_select_dtypes_bad_datetime64(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+        with pytest.raises(ValueError, match=".+ is too specific"):
+            df.select_dtypes(include=["datetime64[D]"])
+
+        with pytest.raises(ValueError, match=".+ is too specific"):
+            df.select_dtypes(exclude=["datetime64[as]"])
+
+    def test_select_dtypes_datetime_with_tz(self):
+        df2 = DataFrame(
+            {
+                "A": Timestamp("20130102", tz="US/Eastern"),
+                "B": Timestamp("20130603", tz="CET"),
+            },
+            index=range(5),
+        )
+        df3 = pd.concat([df2.A.to_frame(), df2.B.to_frame()], axis=1)
+        result = df3.select_dtypes(include=["datetime64[ns]"])
+        expected = df3.reindex(columns=[])
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [str, "str", np.bytes_, "S1", np.str_, "U1"])
+    @pytest.mark.parametrize("arg", ["include", "exclude"])
+    def test_select_dtypes_str_raises(self, dtype, arg):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "g": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+        msg = "string dtypes are not allowed"
+        kwargs = {arg: [dtype]}
+
+        with pytest.raises(TypeError, match=msg):
+            df.select_dtypes(**kwargs)
+
+    def test_select_dtypes_bad_arg_raises(self):
+        df = DataFrame(
+            {
+                "a": list("abc"),
+                "g": list("abc"),
+                "b": list(range(1, 4)),
+                "c": np.arange(3, 6).astype("u1"),
+                "d": np.arange(4.0, 7.0, dtype="float64"),
+                "e": [True, False, True],
+                "f": pd.date_range("now", periods=3).values,
+            }
+        )
+
+        msg = "data type.*not understood"
+        with pytest.raises(TypeError, match=msg):
+            df.select_dtypes(["blargy, blarg, blarg"])
+
+    def test_select_dtypes_typecodes(self):
+        # GH 11990
+        df = tm.makeCustomDataframe(
+            30, 3, data_gen_f=lambda x, y: np.random.default_rng(2).random()
+        )
+        expected = df
+        FLOAT_TYPES = list(np.typecodes["AllFloat"])
+        tm.assert_frame_equal(df.select_dtypes(FLOAT_TYPES), expected)
+
+    @pytest.mark.parametrize(
+        "arr,expected",
+        (
+            (np.array([1, 2], dtype=np.int32), True),
+            (pd.array([1, 2], dtype="Int32"), True),
+            (DummyArray([1, 2], dtype=DummyDtype(numeric=True)), True),
+            (DummyArray([1, 2], dtype=DummyDtype(numeric=False)), False),
+        ),
+    )
+    def test_select_dtypes_numeric(self, arr, expected):
+        # GH 35340
+
+        df = DataFrame(arr)
+        is_selected = df.select_dtypes(np.number).shape == df.shape
+        assert is_selected == expected
+
+    def test_select_dtypes_numeric_nullable_string(self, nullable_string_dtype):
+        arr = pd.array(["a", "b"], dtype=nullable_string_dtype)
+        df = DataFrame(arr)
+        is_selected = df.select_dtypes(np.number).shape == df.shape
+        assert not is_selected
+
+    @pytest.mark.parametrize(
+        "expected, float_dtypes",
+        [
+            [
+                DataFrame(
+                    {"A": range(3), "B": range(5, 8), "C": range(10, 7, -1)}
+                ).astype(dtype={"A": float, "B": np.float64, "C": np.float32}),
+                float,
+            ],
+            [
+                DataFrame(
+                    {"A": range(3), "B": range(5, 8), "C": range(10, 7, -1)}
+                ).astype(dtype={"A": float, "B": np.float64, "C": np.float32}),
+                "float",
+            ],
+            [DataFrame({"C": range(10, 7, -1)}, dtype=np.float32), np.float32],
+            [
+                DataFrame({"A": range(3), "B": range(5, 8)}).astype(
+                    dtype={"A": float, "B": np.float64}
+                ),
+                np.float64,
+            ],
+        ],
+    )
+    def test_select_dtypes_float_dtype(self, expected, float_dtypes):
+        # GH#42452
+        dtype_dict = {"A": float, "B": np.float64, "C": np.float32}
+        df = DataFrame(
+            {"A": range(3), "B": range(5, 8), "C": range(10, 7, -1)},
+        )
+        df = df.astype(dtype_dict)
+        result = df.select_dtypes(include=float_dtypes)
+        tm.assert_frame_equal(result, expected)
+
+    def test_np_bool_ea_boolean_include_number(self):
+        # GH 46870
+        df = DataFrame(
+            {
+                "a": [1, 2, 3],
+                "b": pd.Series([True, False, True], dtype="boolean"),
+                "c": np.array([True, False, True]),
+                "d": pd.Categorical([True, False, True]),
+                "e": pd.arrays.SparseArray([True, False, True]),
+            }
+        )
+        result = df.select_dtypes(include="number")
+        expected = DataFrame({"a": [1, 2, 3]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_select_dtypes_no_view(self):
+        # https://github.com/pandas-dev/pandas/issues/48090
+        # result of this method is not a view on the original dataframe
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        df_orig = df.copy()
+        result = df.select_dtypes(include=["number"])
+        result.iloc[0, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_set_axis.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_set_axis.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d249bc7b7fa471db401ed44e50fdb514cf85a51
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_set_axis.py
@@ -0,0 +1,143 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class SharedSetAxisTests:
+    @pytest.fixture
+    def obj(self):
+        raise NotImplementedError("Implemented by subclasses")
+
+    def test_set_axis(self, obj):
+        # GH14636; this tests setting index for both Series and DataFrame
+        new_index = list("abcd")[: len(obj)]
+        expected = obj.copy()
+        expected.index = new_index
+        result = obj.set_axis(new_index, axis=0)
+        tm.assert_equal(expected, result)
+
+    def test_set_axis_copy(self, obj, using_copy_on_write):
+        # Test copy keyword GH#47932
+        new_index = list("abcd")[: len(obj)]
+
+        orig = obj.iloc[:]
+        expected = obj.copy()
+        expected.index = new_index
+
+        result = obj.set_axis(new_index, axis=0, copy=True)
+        tm.assert_equal(expected, result)
+        assert result is not obj
+        # check we DID make a copy
+        if not using_copy_on_write:
+            if obj.ndim == 1:
+                assert not tm.shares_memory(result, obj)
+            else:
+                assert not any(
+                    tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                    for i in range(obj.shape[1])
+                )
+
+        result = obj.set_axis(new_index, axis=0, copy=False)
+        tm.assert_equal(expected, result)
+        assert result is not obj
+        # check we did NOT make a copy
+        if obj.ndim == 1:
+            assert tm.shares_memory(result, obj)
+        else:
+            assert all(
+                tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                for i in range(obj.shape[1])
+            )
+
+        # copy defaults to True
+        result = obj.set_axis(new_index, axis=0)
+        tm.assert_equal(expected, result)
+        assert result is not obj
+        if using_copy_on_write:
+            # check we DID NOT make a copy
+            if obj.ndim == 1:
+                assert tm.shares_memory(result, obj)
+            else:
+                assert any(
+                    tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                    for i in range(obj.shape[1])
+                )
+        # check we DID make a copy
+        elif obj.ndim == 1:
+            assert not tm.shares_memory(result, obj)
+        else:
+            assert not any(
+                tm.shares_memory(result.iloc[:, i], obj.iloc[:, i])
+                for i in range(obj.shape[1])
+            )
+
+        res = obj.set_axis(new_index, copy=False)
+        tm.assert_equal(expected, res)
+        # check we did NOT make a copy
+        if res.ndim == 1:
+            assert tm.shares_memory(res, orig)
+        else:
+            assert all(
+                tm.shares_memory(res.iloc[:, i], orig.iloc[:, i])
+                for i in range(res.shape[1])
+            )
+
+    def test_set_axis_unnamed_kwarg_warns(self, obj):
+        # omitting the "axis" parameter
+        new_index = list("abcd")[: len(obj)]
+
+        expected = obj.copy()
+        expected.index = new_index
+
+        result = obj.set_axis(new_index)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("axis", [3, "foo"])
+    def test_set_axis_invalid_axis_name(self, axis, obj):
+        # wrong values for the "axis" parameter
+        with pytest.raises(ValueError, match="No axis named"):
+            obj.set_axis(list("abc"), axis=axis)
+
+    def test_set_axis_setattr_index_not_collection(self, obj):
+        # wrong type
+        msg = (
+            r"Index\(\.\.\.\) must be called with a collection of some "
+            r"kind, None was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            obj.index = None
+
+    def test_set_axis_setattr_index_wrong_length(self, obj):
+        # wrong length
+        msg = (
+            f"Length mismatch: Expected axis has {len(obj)} elements, "
+            f"new values have {len(obj)-1} elements"
+        )
+        with pytest.raises(ValueError, match=msg):
+            obj.index = np.arange(len(obj) - 1)
+
+        if obj.ndim == 2:
+            with pytest.raises(ValueError, match="Length mismatch"):
+                obj.columns = obj.columns[::2]
+
+
+class TestDataFrameSetAxis(SharedSetAxisTests):
+    @pytest.fixture
+    def obj(self):
+        df = DataFrame(
+            {"A": [1.1, 2.2, 3.3], "B": [5.0, 6.1, 7.2], "C": [4.4, 5.5, 6.6]},
+            index=[2010, 2011, 2012],
+        )
+        return df
+
+
+class TestSeriesSetAxis(SharedSetAxisTests):
+    @pytest.fixture
+    def obj(self):
+        ser = Series(np.arange(4), index=[1, 3, 5, 7], dtype="int64")
+        return ser
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_set_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_set_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..5984e591dd6c113c50939ed5aa69a9481951271e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_set_index.py
@@ -0,0 +1,702 @@
+"""
+See also: test_reindex.py:TestReindexSetIndex
+"""
+
+from datetime import (
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    date_range,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+class TestSetIndex:
+    def test_set_index_multiindex(self):
+        # segfault in GH#3308
+        d = {"t1": [2, 2.5, 3], "t2": [4, 5, 6]}
+        df = DataFrame(d)
+        tuples = [(0, 1), (0, 2), (1, 2)]
+        df["tuples"] = tuples
+
+        index = MultiIndex.from_tuples(df["tuples"])
+        # it works!
+        df.set_index(index)
+
+    def test_set_index_empty_column(self):
+        # GH#1971
+        df = DataFrame(
+            [
+                {"a": 1, "p": 0},
+                {"a": 2, "m": 10},
+                {"a": 3, "m": 11, "p": 20},
+                {"a": 4, "m": 12, "p": 21},
+            ],
+            columns=["a", "m", "p", "x"],
+        )
+
+        result = df.set_index(["a", "x"])
+
+        expected = df[["m", "p"]]
+        expected.index = MultiIndex.from_arrays([df["a"], df["x"]], names=["a", "x"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_set_index_empty_dataframe(self):
+        # GH#38419
+        df1 = DataFrame(
+            {"a": Series(dtype="datetime64[ns]"), "b": Series(dtype="int64"), "c": []}
+        )
+
+        df2 = df1.set_index(["a", "b"])
+        result = df2.index.to_frame().dtypes
+        expected = df1[["a", "b"]].dtypes
+        tm.assert_series_equal(result, expected)
+
+    def test_set_index_multiindexcolumns(self):
+        columns = MultiIndex.from_tuples([("foo", 1), ("foo", 2), ("bar", 1)])
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 3)), columns=columns
+        )
+
+        result = df.set_index(df.columns[0])
+
+        expected = df.iloc[:, 1:]
+        expected.index = df.iloc[:, 0].values
+        expected.index.names = [df.columns[0]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_set_index_timezone(self):
+        # GH#12358
+        # tz-aware Series should retain the tz
+        idx = DatetimeIndex(["2014-01-01 10:10:10"], tz="UTC").tz_convert("Europe/Rome")
+        df = DataFrame({"A": idx})
+        assert df.set_index(idx).index[0].hour == 11
+        assert DatetimeIndex(Series(df.A))[0].hour == 11
+        assert df.set_index(df.A).index[0].hour == 11
+
+    def test_set_index_cast_datetimeindex(self):
+        df = DataFrame(
+            {
+                "A": [datetime(2000, 1, 1) + timedelta(i) for i in range(1000)],
+                "B": np.random.default_rng(2).standard_normal(1000),
+            }
+        )
+
+        idf = df.set_index("A")
+        assert isinstance(idf.index, DatetimeIndex)
+
+    def test_set_index_dst(self):
+        di = date_range("2006-10-29 00:00:00", periods=3, freq="H", tz="US/Pacific")
+
+        df = DataFrame(data={"a": [0, 1, 2], "b": [3, 4, 5]}, index=di).reset_index()
+        # single level
+        res = df.set_index("index")
+        exp = DataFrame(
+            data={"a": [0, 1, 2], "b": [3, 4, 5]},
+            index=Index(di, name="index"),
+        )
+        exp.index = exp.index._with_freq(None)
+        tm.assert_frame_equal(res, exp)
+
+        # GH#12920
+        res = df.set_index(["index", "a"])
+        exp_index = MultiIndex.from_arrays([di, [0, 1, 2]], names=["index", "a"])
+        exp = DataFrame({"b": [3, 4, 5]}, index=exp_index)
+        tm.assert_frame_equal(res, exp)
+
+    def test_set_index(self, float_string_frame):
+        df = float_string_frame
+        idx = Index(np.arange(len(df))[::-1])
+
+        df = df.set_index(idx)
+        tm.assert_index_equal(df.index, idx)
+        with pytest.raises(ValueError, match="Length mismatch"):
+            df.set_index(idx[::2])
+
+    def test_set_index_names(self):
+        df = tm.makeDataFrame()
+        df.index.name = "name"
+
+        assert df.set_index(df.index).index.names == ["name"]
+
+        mi = MultiIndex.from_arrays(df[["A", "B"]].T.values, names=["A", "B"])
+        mi2 = MultiIndex.from_arrays(
+            df[["A", "B", "A", "B"]].T.values, names=["A", "B", "C", "D"]
+        )
+
+        df = df.set_index(["A", "B"])
+
+        assert df.set_index(df.index).index.names == ["A", "B"]
+
+        # Check that set_index isn't converting a MultiIndex into an Index
+        assert isinstance(df.set_index(df.index).index, MultiIndex)
+
+        # Check actual equality
+        tm.assert_index_equal(df.set_index(df.index).index, mi)
+
+        idx2 = df.index.rename(["C", "D"])
+
+        # Check that [MultiIndex, MultiIndex] yields a MultiIndex rather
+        # than a pair of tuples
+        assert isinstance(df.set_index([df.index, idx2]).index, MultiIndex)
+
+        # Check equality
+        tm.assert_index_equal(df.set_index([df.index, idx2]).index, mi2)
+
+    # A has duplicate values, C does not
+    @pytest.mark.parametrize("keys", ["A", "C", ["A", "B"], ("tuple", "as", "label")])
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_drop_inplace(self, frame_of_index_cols, drop, inplace, keys):
+        df = frame_of_index_cols
+
+        if isinstance(keys, list):
+            idx = MultiIndex.from_arrays([df[x] for x in keys], names=keys)
+        else:
+            idx = Index(df[keys], name=keys)
+        expected = df.drop(keys, axis=1) if drop else df
+        expected.index = idx
+
+        if inplace:
+            result = df.copy()
+            return_value = result.set_index(keys, drop=drop, inplace=True)
+            assert return_value is None
+        else:
+            result = df.set_index(keys, drop=drop)
+
+        tm.assert_frame_equal(result, expected)
+
+    # A has duplicate values, C does not
+    @pytest.mark.parametrize("keys", ["A", "C", ["A", "B"], ("tuple", "as", "label")])
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_append(self, frame_of_index_cols, drop, keys):
+        df = frame_of_index_cols
+
+        keys = keys if isinstance(keys, list) else [keys]
+        idx = MultiIndex.from_arrays(
+            [df.index] + [df[x] for x in keys], names=[None] + keys
+        )
+        expected = df.drop(keys, axis=1) if drop else df.copy()
+        expected.index = idx
+
+        result = df.set_index(keys, drop=drop, append=True)
+
+        tm.assert_frame_equal(result, expected)
+
+    # A has duplicate values, C does not
+    @pytest.mark.parametrize("keys", ["A", "C", ["A", "B"], ("tuple", "as", "label")])
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_append_to_multiindex(self, frame_of_index_cols, drop, keys):
+        # append to existing multiindex
+        df = frame_of_index_cols.set_index(["D"], drop=drop, append=True)
+
+        keys = keys if isinstance(keys, list) else [keys]
+        expected = frame_of_index_cols.set_index(["D"] + keys, drop=drop, append=True)
+
+        result = df.set_index(keys, drop=drop, append=True)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_set_index_after_mutation(self):
+        # GH#1590
+        df = DataFrame({"val": [0, 1, 2], "key": ["a", "b", "c"]})
+        expected = DataFrame({"val": [1, 2]}, Index(["b", "c"], name="key"))
+
+        df2 = df.loc[df.index.map(lambda indx: indx >= 1)]
+        result = df2.set_index("key")
+        tm.assert_frame_equal(result, expected)
+
+    # MultiIndex constructor does not work directly on Series -> lambda
+    # Add list-of-list constructor because list is ambiguous -> lambda
+    # also test index name if append=True (name is duplicate here for B)
+    @pytest.mark.parametrize(
+        "box",
+        [
+            Series,
+            Index,
+            np.array,
+            list,
+            lambda x: [list(x)],
+            lambda x: MultiIndex.from_arrays([x]),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "append, index_name", [(True, None), (True, "B"), (True, "test"), (False, None)]
+    )
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_pass_single_array(
+        self, frame_of_index_cols, drop, append, index_name, box
+    ):
+        df = frame_of_index_cols
+        df.index.name = index_name
+
+        key = box(df["B"])
+        if box == list:
+            # list of strings gets interpreted as list of keys
+            msg = "['one', 'two', 'three', 'one', 'two']"
+            with pytest.raises(KeyError, match=msg):
+                df.set_index(key, drop=drop, append=append)
+        else:
+            # np.array/list-of-list "forget" the name of B
+            name_mi = getattr(key, "names", None)
+            name = [getattr(key, "name", None)] if name_mi is None else name_mi
+
+            result = df.set_index(key, drop=drop, append=append)
+
+            # only valid column keys are dropped
+            # since B is always passed as array above, nothing is dropped
+            expected = df.set_index(["B"], drop=False, append=append)
+            expected.index.names = [index_name] + name if append else name
+
+            tm.assert_frame_equal(result, expected)
+
+    # MultiIndex constructor does not work directly on Series -> lambda
+    # also test index name if append=True (name is duplicate here for A & B)
+    @pytest.mark.parametrize(
+        "box", [Series, Index, np.array, list, lambda x: MultiIndex.from_arrays([x])]
+    )
+    @pytest.mark.parametrize(
+        "append, index_name",
+        [(True, None), (True, "A"), (True, "B"), (True, "test"), (False, None)],
+    )
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_pass_arrays(
+        self, frame_of_index_cols, drop, append, index_name, box
+    ):
+        df = frame_of_index_cols
+        df.index.name = index_name
+
+        keys = ["A", box(df["B"])]
+        # np.array/list "forget" the name of B
+        names = ["A", None if box in [np.array, list, tuple, iter] else "B"]
+
+        result = df.set_index(keys, drop=drop, append=append)
+
+        # only valid column keys are dropped
+        # since B is always passed as array above, only A is dropped, if at all
+        expected = df.set_index(["A", "B"], drop=False, append=append)
+        expected = expected.drop("A", axis=1) if drop else expected
+        expected.index.names = [index_name] + names if append else names
+
+        tm.assert_frame_equal(result, expected)
+
+    # MultiIndex constructor does not work directly on Series -> lambda
+    # We also emulate a "constructor" for the label -> lambda
+    # also test index name if append=True (name is duplicate here for A)
+    @pytest.mark.parametrize(
+        "box2",
+        [
+            Series,
+            Index,
+            np.array,
+            list,
+            iter,
+            lambda x: MultiIndex.from_arrays([x]),
+            lambda x: x.name,
+        ],
+    )
+    @pytest.mark.parametrize(
+        "box1",
+        [
+            Series,
+            Index,
+            np.array,
+            list,
+            iter,
+            lambda x: MultiIndex.from_arrays([x]),
+            lambda x: x.name,
+        ],
+    )
+    @pytest.mark.parametrize(
+        "append, index_name", [(True, None), (True, "A"), (True, "test"), (False, None)]
+    )
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_pass_arrays_duplicate(
+        self, frame_of_index_cols, drop, append, index_name, box1, box2
+    ):
+        df = frame_of_index_cols
+        df.index.name = index_name
+
+        keys = [box1(df["A"]), box2(df["A"])]
+        result = df.set_index(keys, drop=drop, append=append)
+
+        # if either box is iter, it has been consumed; re-read
+        keys = [box1(df["A"]), box2(df["A"])]
+
+        # need to adapt first drop for case that both keys are 'A' --
+        # cannot drop the same column twice;
+        # plain == would give ambiguous Boolean error for containers
+        first_drop = (
+            False
+            if (
+                isinstance(keys[0], str)
+                and keys[0] == "A"
+                and isinstance(keys[1], str)
+                and keys[1] == "A"
+            )
+            else drop
+        )
+        # to test against already-tested behaviour, we add sequentially,
+        # hence second append always True; must wrap keys in list, otherwise
+        # box = list would be interpreted as keys
+        expected = df.set_index([keys[0]], drop=first_drop, append=append)
+        expected = expected.set_index([keys[1]], drop=drop, append=True)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("append", [True, False])
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_pass_multiindex(self, frame_of_index_cols, drop, append):
+        df = frame_of_index_cols
+        keys = MultiIndex.from_arrays([df["A"], df["B"]], names=["A", "B"])
+
+        result = df.set_index(keys, drop=drop, append=append)
+
+        # setting with a MultiIndex will never drop columns
+        expected = df.set_index(["A", "B"], drop=False, append=append)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_construction_with_categorical_index(self):
+        ci = tm.makeCategoricalIndex(10)
+        ci.name = "B"
+
+        # with Categorical
+        df = DataFrame(
+            {"A": np.random.default_rng(2).standard_normal(10), "B": ci.values}
+        )
+        idf = df.set_index("B")
+        tm.assert_index_equal(idf.index, ci)
+
+        # from a CategoricalIndex
+        df = DataFrame({"A": np.random.default_rng(2).standard_normal(10), "B": ci})
+        idf = df.set_index("B")
+        tm.assert_index_equal(idf.index, ci)
+
+        # round-trip
+        idf = idf.reset_index().set_index("B")
+        tm.assert_index_equal(idf.index, ci)
+
+    def test_set_index_preserve_categorical_dtype(self):
+        # GH#13743, GH#13854
+        df = DataFrame(
+            {
+                "A": [1, 2, 1, 1, 2],
+                "B": [10, 16, 22, 28, 34],
+                "C1": Categorical(list("abaab"), categories=list("bac"), ordered=False),
+                "C2": Categorical(list("abaab"), categories=list("bac"), ordered=True),
+            }
+        )
+        for cols in ["C1", "C2", ["A", "C1"], ["A", "C2"], ["C1", "C2"]]:
+            result = df.set_index(cols).reset_index()
+            result = result.reindex(columns=df.columns)
+            tm.assert_frame_equal(result, df)
+
+    def test_set_index_datetime(self):
+        # GH#3950
+        df = DataFrame(
+            {
+                "label": ["a", "a", "a", "b", "b", "b"],
+                "datetime": [
+                    "2011-07-19 07:00:00",
+                    "2011-07-19 08:00:00",
+                    "2011-07-19 09:00:00",
+                    "2011-07-19 07:00:00",
+                    "2011-07-19 08:00:00",
+                    "2011-07-19 09:00:00",
+                ],
+                "value": range(6),
+            }
+        )
+        df.index = to_datetime(df.pop("datetime"), utc=True)
+        df.index = df.index.tz_convert("US/Pacific")
+
+        expected = DatetimeIndex(
+            ["2011-07-19 07:00:00", "2011-07-19 08:00:00", "2011-07-19 09:00:00"],
+            name="datetime",
+        )
+        expected = expected.tz_localize("UTC").tz_convert("US/Pacific")
+
+        df = df.set_index("label", append=True)
+        tm.assert_index_equal(df.index.levels[0], expected)
+        tm.assert_index_equal(df.index.levels[1], Index(["a", "b"], name="label"))
+        assert df.index.names == ["datetime", "label"]
+
+        df = df.swaplevel(0, 1)
+        tm.assert_index_equal(df.index.levels[0], Index(["a", "b"], name="label"))
+        tm.assert_index_equal(df.index.levels[1], expected)
+        assert df.index.names == ["label", "datetime"]
+
+        df = DataFrame(np.random.default_rng(2).random(6))
+        idx1 = DatetimeIndex(
+            [
+                "2011-07-19 07:00:00",
+                "2011-07-19 08:00:00",
+                "2011-07-19 09:00:00",
+                "2011-07-19 07:00:00",
+                "2011-07-19 08:00:00",
+                "2011-07-19 09:00:00",
+            ],
+            tz="US/Eastern",
+        )
+        idx2 = DatetimeIndex(
+            [
+                "2012-04-01 09:00",
+                "2012-04-01 09:00",
+                "2012-04-01 09:00",
+                "2012-04-02 09:00",
+                "2012-04-02 09:00",
+                "2012-04-02 09:00",
+            ],
+            tz="US/Eastern",
+        )
+        idx3 = date_range("2011-01-01 09:00", periods=6, tz="Asia/Tokyo")
+        idx3 = idx3._with_freq(None)
+
+        df = df.set_index(idx1)
+        df = df.set_index(idx2, append=True)
+        df = df.set_index(idx3, append=True)
+
+        expected1 = DatetimeIndex(
+            ["2011-07-19 07:00:00", "2011-07-19 08:00:00", "2011-07-19 09:00:00"],
+            tz="US/Eastern",
+        )
+        expected2 = DatetimeIndex(
+            ["2012-04-01 09:00", "2012-04-02 09:00"], tz="US/Eastern"
+        )
+
+        tm.assert_index_equal(df.index.levels[0], expected1)
+        tm.assert_index_equal(df.index.levels[1], expected2)
+        tm.assert_index_equal(df.index.levels[2], idx3)
+
+        # GH#7092
+        tm.assert_index_equal(df.index.get_level_values(0), idx1)
+        tm.assert_index_equal(df.index.get_level_values(1), idx2)
+        tm.assert_index_equal(df.index.get_level_values(2), idx3)
+
+    def test_set_index_period(self):
+        # GH#6631
+        df = DataFrame(np.random.default_rng(2).random(6))
+        idx1 = period_range("2011-01-01", periods=3, freq="M")
+        idx1 = idx1.append(idx1)
+        idx2 = period_range("2013-01-01 09:00", periods=2, freq="H")
+        idx2 = idx2.append(idx2).append(idx2)
+        idx3 = period_range("2005", periods=6, freq="A")
+
+        df = df.set_index(idx1)
+        df = df.set_index(idx2, append=True)
+        df = df.set_index(idx3, append=True)
+
+        expected1 = period_range("2011-01-01", periods=3, freq="M")
+        expected2 = period_range("2013-01-01 09:00", periods=2, freq="H")
+
+        tm.assert_index_equal(df.index.levels[0], expected1)
+        tm.assert_index_equal(df.index.levels[1], expected2)
+        tm.assert_index_equal(df.index.levels[2], idx3)
+
+        tm.assert_index_equal(df.index.get_level_values(0), idx1)
+        tm.assert_index_equal(df.index.get_level_values(1), idx2)
+        tm.assert_index_equal(df.index.get_level_values(2), idx3)
+
+
+class TestSetIndexInvalid:
+    def test_set_index_verify_integrity(self, frame_of_index_cols):
+        df = frame_of_index_cols
+
+        with pytest.raises(ValueError, match="Index has duplicate keys"):
+            df.set_index("A", verify_integrity=True)
+        # with MultiIndex
+        with pytest.raises(ValueError, match="Index has duplicate keys"):
+            df.set_index([df["A"], df["A"]], verify_integrity=True)
+
+    @pytest.mark.parametrize("append", [True, False])
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_raise_keys(self, frame_of_index_cols, drop, append):
+        df = frame_of_index_cols
+
+        with pytest.raises(KeyError, match="['foo', 'bar', 'baz']"):
+            # column names are A-E, as well as one tuple
+            df.set_index(["foo", "bar", "baz"], drop=drop, append=append)
+
+        # non-existent key in list with arrays
+        with pytest.raises(KeyError, match="X"):
+            df.set_index([df["A"], df["B"], "X"], drop=drop, append=append)
+
+        msg = "[('foo', 'foo', 'foo', 'bar', 'bar')]"
+        # tuples always raise KeyError
+        with pytest.raises(KeyError, match=msg):
+            df.set_index(tuple(df["A"]), drop=drop, append=append)
+
+        # also within a list
+        with pytest.raises(KeyError, match=msg):
+            df.set_index(["A", df["A"], tuple(df["A"])], drop=drop, append=append)
+
+    @pytest.mark.parametrize("append", [True, False])
+    @pytest.mark.parametrize("drop", [True, False])
+    @pytest.mark.parametrize("box", [set], ids=["set"])
+    def test_set_index_raise_on_type(self, frame_of_index_cols, box, drop, append):
+        df = frame_of_index_cols
+
+        msg = 'The parameter "keys" may be a column key, .*'
+        # forbidden type, e.g. set
+        with pytest.raises(TypeError, match=msg):
+            df.set_index(box(df["A"]), drop=drop, append=append)
+
+        # forbidden type in list, e.g. set
+        with pytest.raises(TypeError, match=msg):
+            df.set_index(["A", df["A"], box(df["A"])], drop=drop, append=append)
+
+    # MultiIndex constructor does not work directly on Series -> lambda
+    @pytest.mark.parametrize(
+        "box",
+        [Series, Index, np.array, iter, lambda x: MultiIndex.from_arrays([x])],
+        ids=["Series", "Index", "np.array", "iter", "MultiIndex"],
+    )
+    @pytest.mark.parametrize("length", [4, 6], ids=["too_short", "too_long"])
+    @pytest.mark.parametrize("append", [True, False])
+    @pytest.mark.parametrize("drop", [True, False])
+    def test_set_index_raise_on_len(
+        self, frame_of_index_cols, box, length, drop, append
+    ):
+        # GH 24984
+        df = frame_of_index_cols  # has length 5
+
+        values = np.random.default_rng(2).integers(0, 10, (length,))
+
+        msg = "Length mismatch: Expected 5 rows, received array of length.*"
+
+        # wrong length directly
+        with pytest.raises(ValueError, match=msg):
+            df.set_index(box(values), drop=drop, append=append)
+
+        # wrong length in list
+        with pytest.raises(ValueError, match=msg):
+            df.set_index(["A", df.A, box(values)], drop=drop, append=append)
+
+
+class TestSetIndexCustomLabelType:
+    def test_set_index_custom_label_type(self):
+        # GH#24969
+
+        class Thing:
+            def __init__(self, name, color) -> None:
+                self.name = name
+                self.color = color
+
+            def __str__(self) -> str:
+                return f"<Thing {repr(self.name)}>"
+
+            # necessary for pretty KeyError
+            __repr__ = __str__
+
+        thing1 = Thing("One", "red")
+        thing2 = Thing("Two", "blue")
+        df = DataFrame({thing1: [0, 1], thing2: [2, 3]})
+        expected = DataFrame({thing1: [0, 1]}, index=Index([2, 3], name=thing2))
+
+        # use custom label directly
+        result = df.set_index(thing2)
+        tm.assert_frame_equal(result, expected)
+
+        # custom label wrapped in list
+        result = df.set_index([thing2])
+        tm.assert_frame_equal(result, expected)
+
+        # missing key
+        thing3 = Thing("Three", "pink")
+        msg = "<Thing 'Three'>"
+        with pytest.raises(KeyError, match=msg):
+            # missing label directly
+            df.set_index(thing3)
+
+        with pytest.raises(KeyError, match=msg):
+            # missing label in list
+            df.set_index([thing3])
+
+    def test_set_index_custom_label_hashable_iterable(self):
+        # GH#24969
+
+        # actual example discussed in GH 24984 was e.g. for shapely.geometry
+        # objects (e.g. a collection of Points) that can be both hashable and
+        # iterable; using frozenset as a stand-in for testing here
+
+        class Thing(frozenset):
+            # need to stabilize repr for KeyError (due to random order in sets)
+            def __repr__(self) -> str:
+                tmp = sorted(self)
+                joined_reprs = ", ".join(map(repr, tmp))
+                # double curly brace prints one brace in format string
+                return f"frozenset({{{joined_reprs}}})"
+
+        thing1 = Thing(["One", "red"])
+        thing2 = Thing(["Two", "blue"])
+        df = DataFrame({thing1: [0, 1], thing2: [2, 3]})
+        expected = DataFrame({thing1: [0, 1]}, index=Index([2, 3], name=thing2))
+
+        # use custom label directly
+        result = df.set_index(thing2)
+        tm.assert_frame_equal(result, expected)
+
+        # custom label wrapped in list
+        result = df.set_index([thing2])
+        tm.assert_frame_equal(result, expected)
+
+        # missing key
+        thing3 = Thing(["Three", "pink"])
+        msg = r"frozenset\(\{'Three', 'pink'\}\)"
+        with pytest.raises(KeyError, match=msg):
+            # missing label directly
+            df.set_index(thing3)
+
+        with pytest.raises(KeyError, match=msg):
+            # missing label in list
+            df.set_index([thing3])
+
+    def test_set_index_custom_label_type_raises(self):
+        # GH#24969
+
+        # purposefully inherit from something unhashable
+        class Thing(set):
+            def __init__(self, name, color) -> None:
+                self.name = name
+                self.color = color
+
+            def __str__(self) -> str:
+                return f"<Thing {repr(self.name)}>"
+
+        thing1 = Thing("One", "red")
+        thing2 = Thing("Two", "blue")
+        df = DataFrame([[0, 2], [1, 3]], columns=[thing1, thing2])
+
+        msg = 'The parameter "keys" may be a column key, .*'
+
+        with pytest.raises(TypeError, match=msg):
+            # use custom label directly
+            df.set_index(thing2)
+
+        with pytest.raises(TypeError, match=msg):
+            # custom label wrapped in list
+            df.set_index([thing2])
+
+    def test_set_index_periodindex(self):
+        # GH#6631
+        df = DataFrame(np.random.default_rng(2).random(6))
+        idx1 = period_range("2011/01/01", periods=6, freq="M")
+        idx2 = period_range("2013", periods=6, freq="A")
+
+        df = df.set_index(idx1)
+        tm.assert_index_equal(df.index, idx1)
+        df = df.set_index(idx2)
+        tm.assert_index_equal(df.index, idx2)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_shift.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_shift.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e88152137b1f996890f93bd065ca7480597514a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_shift.py
@@ -0,0 +1,756 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    CategoricalIndex,
+    DataFrame,
+    Index,
+    NaT,
+    Series,
+    date_range,
+    offsets,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameShift:
+    def test_shift_axis1_with_valid_fill_value_one_array(self):
+        # Case with axis=1 that does not go through the "len(arrays)>1" path
+        #  in DataFrame.shift
+        data = np.random.default_rng(2).standard_normal((5, 3))
+        df = DataFrame(data)
+        res = df.shift(axis=1, periods=1, fill_value=12345)
+        expected = df.T.shift(periods=1, fill_value=12345).T
+        tm.assert_frame_equal(res, expected)
+
+        # same but with an 1D ExtensionArray backing it
+        df2 = df[[0]].astype("Float64")
+        res2 = df2.shift(axis=1, periods=1, fill_value=12345)
+        expected2 = DataFrame([12345] * 5, dtype="Float64")
+        tm.assert_frame_equal(res2, expected2)
+
+    def test_shift_deprecate_freq_and_fill_value(self, frame_or_series):
+        # Can't pass both!
+        obj = frame_or_series(
+            np.random.default_rng(2).standard_normal(5),
+            index=date_range("1/1/2000", periods=5, freq="H"),
+        )
+
+        msg = (
+            "Passing a 'freq' together with a 'fill_value' silently ignores the "
+            "fill_value"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            obj.shift(1, fill_value=1, freq="H")
+
+        if frame_or_series is DataFrame:
+            obj.columns = date_range("1/1/2000", periods=1, freq="H")
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                obj.shift(1, axis=1, fill_value=1, freq="H")
+
+    @pytest.mark.parametrize(
+        "input_data, output_data",
+        [(np.empty(shape=(0,)), []), (np.ones(shape=(2,)), [np.nan, 1.0])],
+    )
+    def test_shift_non_writable_array(self, input_data, output_data, frame_or_series):
+        # GH21049 Verify whether non writable numpy array is shiftable
+        input_data.setflags(write=False)
+
+        result = frame_or_series(input_data).shift(1)
+        if frame_or_series is not Series:
+            # need to explicitly specify columns in the empty case
+            expected = frame_or_series(
+                output_data,
+                index=range(len(output_data)),
+                columns=range(1),
+                dtype="float64",
+            )
+        else:
+            expected = frame_or_series(output_data, dtype="float64")
+
+        tm.assert_equal(result, expected)
+
+    def test_shift_mismatched_freq(self, frame_or_series):
+        ts = frame_or_series(
+            np.random.default_rng(2).standard_normal(5),
+            index=date_range("1/1/2000", periods=5, freq="H"),
+        )
+
+        result = ts.shift(1, freq="5T")
+        exp_index = ts.index.shift(1, freq="5T")
+        tm.assert_index_equal(result.index, exp_index)
+
+        # GH#1063, multiple of same base
+        result = ts.shift(1, freq="4H")
+        exp_index = ts.index + offsets.Hour(4)
+        tm.assert_index_equal(result.index, exp_index)
+
+    @pytest.mark.parametrize(
+        "obj",
+        [
+            Series([np.arange(5)]),
+            date_range("1/1/2011", periods=24, freq="H"),
+            Series(range(5), index=date_range("2017", periods=5)),
+        ],
+    )
+    @pytest.mark.parametrize("shift_size", [0, 1, 2])
+    def test_shift_always_copy(self, obj, shift_size, frame_or_series):
+        # GH#22397
+        if frame_or_series is not Series:
+            obj = obj.to_frame()
+        assert obj.shift(shift_size) is not obj
+
+    def test_shift_object_non_scalar_fill(self):
+        # shift requires scalar fill_value except for object dtype
+        ser = Series(range(3))
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            ser.shift(1, fill_value=[])
+
+        df = ser.to_frame()
+        with pytest.raises(ValueError, match="fill_value must be a scalar"):
+            df.shift(1, fill_value=np.arange(3))
+
+        obj_ser = ser.astype(object)
+        result = obj_ser.shift(1, fill_value={})
+        assert result[0] == {}
+
+        obj_df = obj_ser.to_frame()
+        result = obj_df.shift(1, fill_value={})
+        assert result.iloc[0, 0] == {}
+
+    def test_shift_int(self, datetime_frame, frame_or_series):
+        ts = tm.get_obj(datetime_frame, frame_or_series).astype(int)
+        shifted = ts.shift(1)
+        expected = ts.astype(float).shift(1)
+        tm.assert_equal(shifted, expected)
+
+    @pytest.mark.parametrize("dtype", ["int32", "int64"])
+    def test_shift_32bit_take(self, frame_or_series, dtype):
+        # 32-bit taking
+        # GH#8129
+        index = date_range("2000-01-01", periods=5)
+        arr = np.arange(5, dtype=dtype)
+        s1 = frame_or_series(arr, index=index)
+        p = arr[1]
+        result = s1.shift(periods=p)
+        expected = frame_or_series([np.nan, 0, 1, 2, 3], index=index)
+        tm.assert_equal(result, expected)
+
+    @pytest.mark.parametrize("periods", [1, 2, 3, 4])
+    def test_shift_preserve_freqstr(self, periods, frame_or_series):
+        # GH#21275
+        obj = frame_or_series(
+            range(periods),
+            index=date_range("2016-1-1 00:00:00", periods=periods, freq="H"),
+        )
+
+        result = obj.shift(1, "2H")
+
+        expected = frame_or_series(
+            range(periods),
+            index=date_range("2016-1-1 02:00:00", periods=periods, freq="H"),
+        )
+        tm.assert_equal(result, expected)
+
+    def test_shift_dst(self, frame_or_series):
+        # GH#13926
+        dates = date_range("2016-11-06", freq="H", periods=10, tz="US/Eastern")
+        obj = frame_or_series(dates)
+
+        res = obj.shift(0)
+        tm.assert_equal(res, obj)
+        assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
+
+        res = obj.shift(1)
+        exp_vals = [NaT] + dates.astype(object).values.tolist()[:9]
+        exp = frame_or_series(exp_vals)
+        tm.assert_equal(res, exp)
+        assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
+
+        res = obj.shift(-2)
+        exp_vals = dates.astype(object).values.tolist()[2:] + [NaT, NaT]
+        exp = frame_or_series(exp_vals)
+        tm.assert_equal(res, exp)
+        assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
+
+    @pytest.mark.parametrize("ex", [10, -10, 20, -20])
+    def test_shift_dst_beyond(self, frame_or_series, ex):
+        # GH#13926
+        dates = date_range("2016-11-06", freq="H", periods=10, tz="US/Eastern")
+        obj = frame_or_series(dates)
+        res = obj.shift(ex)
+        exp = frame_or_series([NaT] * 10, dtype="datetime64[ns, US/Eastern]")
+        tm.assert_equal(res, exp)
+        assert tm.get_dtype(res) == "datetime64[ns, US/Eastern]"
+
+    def test_shift_by_zero(self, datetime_frame, frame_or_series):
+        # shift by 0
+        obj = tm.get_obj(datetime_frame, frame_or_series)
+        unshifted = obj.shift(0)
+        tm.assert_equal(unshifted, obj)
+
+    def test_shift(self, datetime_frame):
+        # naive shift
+        ser = datetime_frame["A"]
+
+        shifted = datetime_frame.shift(5)
+        tm.assert_index_equal(shifted.index, datetime_frame.index)
+
+        shifted_ser = ser.shift(5)
+        tm.assert_series_equal(shifted["A"], shifted_ser)
+
+        shifted = datetime_frame.shift(-5)
+        tm.assert_index_equal(shifted.index, datetime_frame.index)
+
+        shifted_ser = ser.shift(-5)
+        tm.assert_series_equal(shifted["A"], shifted_ser)
+
+        unshifted = datetime_frame.shift(5).shift(-5)
+        tm.assert_numpy_array_equal(
+            unshifted.dropna().values, datetime_frame.values[:-5]
+        )
+
+        unshifted_ser = ser.shift(5).shift(-5)
+        tm.assert_numpy_array_equal(unshifted_ser.dropna().values, ser.values[:-5])
+
+    def test_shift_by_offset(self, datetime_frame, frame_or_series):
+        # shift by DateOffset
+        obj = tm.get_obj(datetime_frame, frame_or_series)
+        offset = offsets.BDay()
+
+        shifted = obj.shift(5, freq=offset)
+        assert len(shifted) == len(obj)
+        unshifted = shifted.shift(-5, freq=offset)
+        tm.assert_equal(unshifted, obj)
+
+        shifted2 = obj.shift(5, freq="B")
+        tm.assert_equal(shifted, shifted2)
+
+        unshifted = obj.shift(0, freq=offset)
+        tm.assert_equal(unshifted, obj)
+
+        d = obj.index[0]
+        shifted_d = d + offset * 5
+        if frame_or_series is DataFrame:
+            tm.assert_series_equal(obj.xs(d), shifted.xs(shifted_d), check_names=False)
+        else:
+            tm.assert_almost_equal(obj.at[d], shifted.at[shifted_d])
+
+    def test_shift_with_periodindex(self, frame_or_series):
+        # Shifting with PeriodIndex
+        ps = tm.makePeriodFrame()
+        ps = tm.get_obj(ps, frame_or_series)
+
+        shifted = ps.shift(1)
+        unshifted = shifted.shift(-1)
+        tm.assert_index_equal(shifted.index, ps.index)
+        tm.assert_index_equal(unshifted.index, ps.index)
+        if frame_or_series is DataFrame:
+            tm.assert_numpy_array_equal(
+                unshifted.iloc[:, 0].dropna().values, ps.iloc[:-1, 0].values
+            )
+        else:
+            tm.assert_numpy_array_equal(unshifted.dropna().values, ps.values[:-1])
+
+        shifted2 = ps.shift(1, "D")
+        shifted3 = ps.shift(1, offsets.Day())
+        tm.assert_equal(shifted2, shifted3)
+        tm.assert_equal(ps, shifted2.shift(-1, "D"))
+
+        msg = "does not match PeriodIndex freq"
+        with pytest.raises(ValueError, match=msg):
+            ps.shift(freq="W")
+
+        # legacy support
+        shifted4 = ps.shift(1, freq="D")
+        tm.assert_equal(shifted2, shifted4)
+
+        shifted5 = ps.shift(1, freq=offsets.Day())
+        tm.assert_equal(shifted5, shifted4)
+
+    def test_shift_other_axis(self):
+        # shift other axis
+        # GH#6371
+        df = DataFrame(np.random.default_rng(2).random((10, 5)))
+        expected = pd.concat(
+            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
+            ignore_index=True,
+            axis=1,
+        )
+        result = df.shift(1, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_shift_named_axis(self):
+        # shift named axis
+        df = DataFrame(np.random.default_rng(2).random((10, 5)))
+        expected = pd.concat(
+            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
+            ignore_index=True,
+            axis=1,
+        )
+        result = df.shift(1, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+    def test_shift_other_axis_with_freq(self, datetime_frame):
+        obj = datetime_frame.T
+        offset = offsets.BDay()
+
+        # GH#47039
+        shifted = obj.shift(5, freq=offset, axis=1)
+        assert len(shifted) == len(obj)
+        unshifted = shifted.shift(-5, freq=offset, axis=1)
+        tm.assert_equal(unshifted, obj)
+
+    def test_shift_bool(self):
+        df = DataFrame({"high": [True, False], "low": [False, False]})
+        rs = df.shift(1)
+        xp = DataFrame(
+            np.array([[np.nan, np.nan], [True, False]], dtype=object),
+            columns=["high", "low"],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+    def test_shift_categorical1(self, frame_or_series):
+        # GH#9416
+        obj = frame_or_series(["a", "b", "c", "d"], dtype="category")
+
+        rt = obj.shift(1).shift(-1)
+        tm.assert_equal(obj.iloc[:-1], rt.dropna())
+
+        def get_cat_values(ndframe):
+            # For Series we could just do ._values; for DataFrame
+            #  we may be able to do this if we ever have 2D Categoricals
+            return ndframe._mgr.arrays[0]
+
+        cat = get_cat_values(obj)
+
+        sp1 = obj.shift(1)
+        tm.assert_index_equal(obj.index, sp1.index)
+        assert np.all(get_cat_values(sp1).codes[:1] == -1)
+        assert np.all(cat.codes[:-1] == get_cat_values(sp1).codes[1:])
+
+        sn2 = obj.shift(-2)
+        tm.assert_index_equal(obj.index, sn2.index)
+        assert np.all(get_cat_values(sn2).codes[-2:] == -1)
+        assert np.all(cat.codes[2:] == get_cat_values(sn2).codes[:-2])
+
+        tm.assert_index_equal(cat.categories, get_cat_values(sp1).categories)
+        tm.assert_index_equal(cat.categories, get_cat_values(sn2).categories)
+
+    def test_shift_categorical(self):
+        # GH#9416
+        s1 = Series(["a", "b", "c"], dtype="category")
+        s2 = Series(["A", "B", "C"], dtype="category")
+        df = DataFrame({"one": s1, "two": s2})
+        rs = df.shift(1)
+        xp = DataFrame({"one": s1.shift(1), "two": s2.shift(1)})
+        tm.assert_frame_equal(rs, xp)
+
+    def test_shift_categorical_fill_value(self, frame_or_series):
+        ts = frame_or_series(["a", "b", "c", "d"], dtype="category")
+        res = ts.shift(1, fill_value="a")
+        expected = frame_or_series(
+            pd.Categorical(
+                ["a", "a", "b", "c"], categories=["a", "b", "c", "d"], ordered=False
+            )
+        )
+        tm.assert_equal(res, expected)
+
+        # check for incorrect fill_value
+        msg = r"Cannot setitem on a Categorical with a new category \(f\)"
+        with pytest.raises(TypeError, match=msg):
+            ts.shift(1, fill_value="f")
+
+    def test_shift_fill_value(self, frame_or_series):
+        # GH#24128
+        dti = date_range("1/1/2000", periods=5, freq="H")
+
+        ts = frame_or_series([1.0, 2.0, 3.0, 4.0, 5.0], index=dti)
+        exp = frame_or_series([0.0, 1.0, 2.0, 3.0, 4.0], index=dti)
+        # check that fill value works
+        result = ts.shift(1, fill_value=0.0)
+        tm.assert_equal(result, exp)
+
+        exp = frame_or_series([0.0, 0.0, 1.0, 2.0, 3.0], index=dti)
+        result = ts.shift(2, fill_value=0.0)
+        tm.assert_equal(result, exp)
+
+        ts = frame_or_series([1, 2, 3])
+        res = ts.shift(2, fill_value=0)
+        assert tm.get_dtype(res) == tm.get_dtype(ts)
+
+        # retain integer dtype
+        obj = frame_or_series([1, 2, 3, 4, 5], index=dti)
+        exp = frame_or_series([0, 1, 2, 3, 4], index=dti)
+        result = obj.shift(1, fill_value=0)
+        tm.assert_equal(result, exp)
+
+        exp = frame_or_series([0, 0, 1, 2, 3], index=dti)
+        result = obj.shift(2, fill_value=0)
+        tm.assert_equal(result, exp)
+
+    def test_shift_empty(self):
+        # Regression test for GH#8019
+        df = DataFrame({"foo": []})
+        rs = df.shift(-1)
+
+        tm.assert_frame_equal(df, rs)
+
+    def test_shift_duplicate_columns(self):
+        # GH#9092; verify that position-based shifting works
+        # in the presence of duplicate columns
+        column_lists = [list(range(5)), [1] * 5, [1, 1, 2, 2, 1]]
+        data = np.random.default_rng(2).standard_normal((20, 5))
+
+        shifted = []
+        for columns in column_lists:
+            df = DataFrame(data.copy(), columns=columns)
+            for s in range(5):
+                df.iloc[:, s] = df.iloc[:, s].shift(s + 1)
+            df.columns = range(5)
+            shifted.append(df)
+
+        # sanity check the base case
+        nulls = shifted[0].isna().sum()
+        tm.assert_series_equal(nulls, Series(range(1, 6), dtype="int64"))
+
+        # check all answers are the same
+        tm.assert_frame_equal(shifted[0], shifted[1])
+        tm.assert_frame_equal(shifted[0], shifted[2])
+
+    def test_shift_axis1_multiple_blocks(self, using_array_manager):
+        # GH#35488
+        df1 = DataFrame(np.random.default_rng(2).integers(1000, size=(5, 3)))
+        df2 = DataFrame(np.random.default_rng(2).integers(1000, size=(5, 2)))
+        df3 = pd.concat([df1, df2], axis=1)
+        if not using_array_manager:
+            assert len(df3._mgr.blocks) == 2
+
+        result = df3.shift(2, axis=1)
+
+        expected = df3.take([-1, -1, 0, 1, 2], axis=1)
+        # Explicit cast to float to avoid implicit cast when setting nan.
+        # Column names aren't unique, so directly calling `expected.astype` won't work.
+        expected = expected.pipe(
+            lambda df: df.set_axis(range(df.shape[1]), axis=1)
+            .astype({0: "float", 1: "float"})
+            .set_axis(df.columns, axis=1)
+        )
+        expected.iloc[:, :2] = np.nan
+        expected.columns = df3.columns
+
+        tm.assert_frame_equal(result, expected)
+
+        # Case with periods < 0
+        # rebuild df3 because `take` call above consolidated
+        df3 = pd.concat([df1, df2], axis=1)
+        if not using_array_manager:
+            assert len(df3._mgr.blocks) == 2
+        result = df3.shift(-2, axis=1)
+
+        expected = df3.take([2, 3, 4, -1, -1], axis=1)
+        # Explicit cast to float to avoid implicit cast when setting nan.
+        # Column names aren't unique, so directly calling `expected.astype` won't work.
+        expected = expected.pipe(
+            lambda df: df.set_axis(range(df.shape[1]), axis=1)
+            .astype({3: "float", 4: "float"})
+            .set_axis(df.columns, axis=1)
+        )
+        expected.iloc[:, -2:] = np.nan
+        expected.columns = df3.columns
+
+        tm.assert_frame_equal(result, expected)
+
+    @td.skip_array_manager_not_yet_implemented  # TODO(ArrayManager) axis=1 support
+    def test_shift_axis1_multiple_blocks_with_int_fill(self):
+        # GH#42719
+        rng = np.random.default_rng(2)
+        df1 = DataFrame(rng.integers(1000, size=(5, 3), dtype=int))
+        df2 = DataFrame(rng.integers(1000, size=(5, 2), dtype=int))
+        df3 = pd.concat([df1.iloc[:4, 1:3], df2.iloc[:4, :]], axis=1)
+        result = df3.shift(2, axis=1, fill_value=np.int_(0))
+        assert len(df3._mgr.blocks) == 2
+
+        expected = df3.take([-1, -1, 0, 1], axis=1)
+        expected.iloc[:, :2] = np.int_(0)
+        expected.columns = df3.columns
+
+        tm.assert_frame_equal(result, expected)
+
+        # Case with periods < 0
+        df3 = pd.concat([df1.iloc[:4, 1:3], df2.iloc[:4, :]], axis=1)
+        result = df3.shift(-2, axis=1, fill_value=np.int_(0))
+        assert len(df3._mgr.blocks) == 2
+
+        expected = df3.take([2, 3, -1, -1], axis=1)
+        expected.iloc[:, -2:] = np.int_(0)
+        expected.columns = df3.columns
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_period_index_frame_shift_with_freq(self, frame_or_series):
+        ps = tm.makePeriodFrame()
+        ps = tm.get_obj(ps, frame_or_series)
+
+        shifted = ps.shift(1, freq="infer")
+        unshifted = shifted.shift(-1, freq="infer")
+        tm.assert_equal(unshifted, ps)
+
+        shifted2 = ps.shift(freq="D")
+        tm.assert_equal(shifted, shifted2)
+
+        shifted3 = ps.shift(freq=offsets.Day())
+        tm.assert_equal(shifted, shifted3)
+
+    def test_datetime_frame_shift_with_freq(self, datetime_frame, frame_or_series):
+        dtobj = tm.get_obj(datetime_frame, frame_or_series)
+        shifted = dtobj.shift(1, freq="infer")
+        unshifted = shifted.shift(-1, freq="infer")
+        tm.assert_equal(dtobj, unshifted)
+
+        shifted2 = dtobj.shift(freq=dtobj.index.freq)
+        tm.assert_equal(shifted, shifted2)
+
+        inferred_ts = DataFrame(
+            datetime_frame.values,
+            Index(np.asarray(datetime_frame.index)),
+            columns=datetime_frame.columns,
+        )
+        inferred_ts = tm.get_obj(inferred_ts, frame_or_series)
+        shifted = inferred_ts.shift(1, freq="infer")
+        expected = dtobj.shift(1, freq="infer")
+        expected.index = expected.index._with_freq(None)
+        tm.assert_equal(shifted, expected)
+
+        unshifted = shifted.shift(-1, freq="infer")
+        tm.assert_equal(unshifted, inferred_ts)
+
+    def test_period_index_frame_shift_with_freq_error(self, frame_or_series):
+        ps = tm.makePeriodFrame()
+        ps = tm.get_obj(ps, frame_or_series)
+        msg = "Given freq M does not match PeriodIndex freq D"
+        with pytest.raises(ValueError, match=msg):
+            ps.shift(freq="M")
+
+    def test_datetime_frame_shift_with_freq_error(
+        self, datetime_frame, frame_or_series
+    ):
+        dtobj = tm.get_obj(datetime_frame, frame_or_series)
+        no_freq = dtobj.iloc[[0, 5, 7]]
+        msg = "Freq was not set in the index hence cannot be inferred"
+        with pytest.raises(ValueError, match=msg):
+            no_freq.shift(freq="infer")
+
+    def test_shift_dt64values_int_fill_deprecated(self):
+        # GH#31971
+        ser = Series([pd.Timestamp("2020-01-01"), pd.Timestamp("2020-01-02")])
+
+        with pytest.raises(TypeError, match="value should be a"):
+            ser.shift(1, fill_value=0)
+
+        df = ser.to_frame()
+        with pytest.raises(TypeError, match="value should be a"):
+            df.shift(1, fill_value=0)
+
+        # axis = 1
+        df2 = DataFrame({"A": ser, "B": ser})
+        df2._consolidate_inplace()
+
+        result = df2.shift(1, axis=1, fill_value=0)
+        expected = DataFrame({"A": [0, 0], "B": df2["A"]})
+        tm.assert_frame_equal(result, expected)
+
+        # same thing but not consolidated; pre-2.0 we got different behavior
+        df3 = DataFrame({"A": ser})
+        df3["B"] = ser
+        assert len(df3._mgr.arrays) == 2
+        result = df3.shift(1, axis=1, fill_value=0)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "as_cat",
+        [
+            pytest.param(
+                True,
+                marks=pytest.mark.xfail(
+                    reason="_can_hold_element incorrectly always returns True"
+                ),
+            ),
+            False,
+        ],
+    )
+    @pytest.mark.parametrize(
+        "vals",
+        [
+            date_range("2020-01-01", periods=2),
+            date_range("2020-01-01", periods=2, tz="US/Pacific"),
+            pd.period_range("2020-01-01", periods=2, freq="D"),
+            pd.timedelta_range("2020 Days", periods=2, freq="D"),
+            pd.interval_range(0, 3, periods=2),
+            pytest.param(
+                pd.array([1, 2], dtype="Int64"),
+                marks=pytest.mark.xfail(
+                    reason="_can_hold_element incorrectly always returns True"
+                ),
+            ),
+            pytest.param(
+                pd.array([1, 2], dtype="Float32"),
+                marks=pytest.mark.xfail(
+                    reason="_can_hold_element incorrectly always returns True"
+                ),
+            ),
+        ],
+        ids=lambda x: str(x.dtype),
+    )
+    def test_shift_dt64values_axis1_invalid_fill(self, vals, as_cat):
+        # GH#44564
+        ser = Series(vals)
+        if as_cat:
+            ser = ser.astype("category")
+
+        df = DataFrame({"A": ser})
+        result = df.shift(-1, axis=1, fill_value="foo")
+        expected = DataFrame({"A": ["foo", "foo"]})
+        tm.assert_frame_equal(result, expected)
+
+        # same thing but multiple blocks
+        df2 = DataFrame({"A": ser, "B": ser})
+        df2._consolidate_inplace()
+
+        result = df2.shift(-1, axis=1, fill_value="foo")
+        expected = DataFrame({"A": df2["B"], "B": ["foo", "foo"]})
+        tm.assert_frame_equal(result, expected)
+
+        # same thing but not consolidated
+        df3 = DataFrame({"A": ser})
+        df3["B"] = ser
+        assert len(df3._mgr.arrays) == 2
+        result = df3.shift(-1, axis=1, fill_value="foo")
+        tm.assert_frame_equal(result, expected)
+
+    def test_shift_axis1_categorical_columns(self):
+        # GH#38434
+        ci = CategoricalIndex(["a", "b", "c"])
+        df = DataFrame(
+            {"a": [1, 3], "b": [2, 4], "c": [5, 6]}, index=ci[:-1], columns=ci
+        )
+        result = df.shift(axis=1)
+
+        expected = DataFrame(
+            {"a": [np.nan, np.nan], "b": [1, 3], "c": [2, 4]}, index=ci[:-1], columns=ci
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # periods != 1
+        result = df.shift(2, axis=1)
+        expected = DataFrame(
+            {"a": [np.nan, np.nan], "b": [np.nan, np.nan], "c": [1, 3]},
+            index=ci[:-1],
+            columns=ci,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_shift_axis1_many_periods(self):
+        # GH#44978 periods > len(columns)
+        df = DataFrame(np.random.default_rng(2).random((5, 3)))
+        shifted = df.shift(6, axis=1, fill_value=None)
+
+        expected = df * np.nan
+        tm.assert_frame_equal(shifted, expected)
+
+        shifted2 = df.shift(-6, axis=1, fill_value=None)
+        tm.assert_frame_equal(shifted2, expected)
+
+    def test_shift_with_offsets_freq(self):
+        df = DataFrame({"x": [1, 2, 3]}, index=date_range("2000", periods=3))
+        shifted = df.shift(freq="1MS")
+        expected = DataFrame(
+            {"x": [1, 2, 3]},
+            index=date_range(start="02/01/2000", end="02/01/2000", periods=3),
+        )
+        tm.assert_frame_equal(shifted, expected)
+
+    def test_shift_with_iterable_basic_functionality(self):
+        # GH#44424
+        data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+        shifts = [0, 1, 2]
+
+        df = DataFrame(data)
+        shifted = df.shift(shifts)
+
+        expected = DataFrame(
+            {
+                "a_0": [1, 2, 3],
+                "b_0": [4, 5, 6],
+                "a_1": [np.nan, 1.0, 2.0],
+                "b_1": [np.nan, 4.0, 5.0],
+                "a_2": [np.nan, np.nan, 1.0],
+                "b_2": [np.nan, np.nan, 4.0],
+            }
+        )
+        tm.assert_frame_equal(expected, shifted)
+
+    def test_shift_with_iterable_series(self):
+        # GH#44424
+        data = {"a": [1, 2, 3]}
+        shifts = [0, 1, 2]
+
+        df = DataFrame(data)
+        s = df["a"]
+        tm.assert_frame_equal(s.shift(shifts), df.shift(shifts))
+
+    def test_shift_with_iterable_freq_and_fill_value(self):
+        # GH#44424
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal(5),
+            index=date_range("1/1/2000", periods=5, freq="H"),
+        )
+
+        tm.assert_frame_equal(
+            # rename because shift with an iterable leads to str column names
+            df.shift([1], fill_value=1).rename(columns=lambda x: int(x[0])),
+            df.shift(1, fill_value=1),
+        )
+
+        tm.assert_frame_equal(
+            df.shift([1], freq="H").rename(columns=lambda x: int(x[0])),
+            df.shift(1, freq="H"),
+        )
+
+        msg = (
+            "Passing a 'freq' together with a 'fill_value' silently ignores the "
+            "fill_value"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            df.shift([1, 2], fill_value=1, freq="H")
+
+    def test_shift_with_iterable_check_other_arguments(self):
+        # GH#44424
+        data = {"a": [1, 2], "b": [4, 5]}
+        shifts = [0, 1]
+        df = DataFrame(data)
+
+        # test suffix
+        shifted = df[["a"]].shift(shifts, suffix="_suffix")
+        expected = DataFrame({"a_suffix_0": [1, 2], "a_suffix_1": [np.nan, 1.0]})
+        tm.assert_frame_equal(shifted, expected)
+
+        # check bad inputs when doing multiple shifts
+        msg = "If `periods` contains multiple shifts, `axis` cannot be 1."
+        with pytest.raises(ValueError, match=msg):
+            df.shift(shifts, axis=1)
+
+        msg = "Periods must be integer, but s is <class 'str'>."
+        with pytest.raises(TypeError, match=msg):
+            df.shift(["s"])
+
+        msg = "If `periods` is an iterable, it cannot be empty."
+        with pytest.raises(ValueError, match=msg):
+            df.shift([])
+
+        msg = "Cannot specify `suffix` if `periods` is an int."
+        with pytest.raises(ValueError, match=msg):
+            df.shift(1, suffix="fails")
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_size.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_size.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c8b6473c85ea8e4a9749e79c8b4459afe6637d8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_size.py
@@ -0,0 +1,21 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+
+
+@pytest.mark.parametrize(
+    "data, index, expected",
+    [
+        ({"col1": [1], "col2": [3]}, None, 2),
+        ({}, None, 0),
+        ({"col1": [1, np.nan], "col2": [3, 4]}, None, 4),
+        ({"col1": [1, 2], "col2": [3, 4]}, [["a", "b"], [1, 2]], 4),
+        ({"col1": [1, 2, 3, 4], "col2": [3, 4, 5, 6]}, ["x", "y", "a", "b"], 8),
+    ],
+)
+def test_size(data, index, expected):
+    # GH#52897
+    df = DataFrame(data, index=index)
+    assert df.size == expected
+    assert isinstance(df.size, int)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sort_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sort_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1465c9ba9df88374036efc3960685ee797c3c6e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sort_index.py
@@ -0,0 +1,996 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    CategoricalDtype,
+    CategoricalIndex,
+    DataFrame,
+    IntervalIndex,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameSortIndex:
+    def test_sort_index_and_reconstruction_doc_example(self):
+        # doc example
+        df = DataFrame(
+            {"value": [1, 2, 3, 4]},
+            index=MultiIndex(
+                levels=[["a", "b"], ["bb", "aa"]], codes=[[0, 0, 1, 1], [0, 1, 0, 1]]
+            ),
+        )
+        assert df.index._is_lexsorted()
+        assert not df.index.is_monotonic_increasing
+
+        # sort it
+        expected = DataFrame(
+            {"value": [2, 1, 4, 3]},
+            index=MultiIndex(
+                levels=[["a", "b"], ["aa", "bb"]], codes=[[0, 0, 1, 1], [0, 1, 0, 1]]
+            ),
+        )
+        result = df.sort_index()
+        assert result.index.is_monotonic_increasing
+        tm.assert_frame_equal(result, expected)
+
+        # reconstruct
+        result = df.sort_index().copy()
+        result.index = result.index._sort_levels_monotonic()
+        assert result.index.is_monotonic_increasing
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_non_existent_label_multiindex(self):
+        # GH#12261
+        df = DataFrame(0, columns=[], index=MultiIndex.from_product([[], []]))
+        with tm.assert_produces_warning(None):
+            df.loc["b", "2"] = 1
+            df.loc["a", "3"] = 1
+        result = df.sort_index().index.is_monotonic_increasing
+        assert result is True
+
+    def test_sort_index_reorder_on_ops(self):
+        # GH#15687
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((8, 2)),
+            index=MultiIndex.from_product(
+                [["a", "b"], ["big", "small"], ["red", "blu"]],
+                names=["letter", "size", "color"],
+            ),
+            columns=["near", "far"],
+        )
+        df = df.sort_index()
+
+        def my_func(group):
+            group.index = ["newz", "newa"]
+            return group
+
+        result = df.groupby(level=["letter", "size"]).apply(my_func).sort_index()
+        expected = MultiIndex.from_product(
+            [["a", "b"], ["big", "small"], ["newa", "newz"]],
+            names=["letter", "size", None],
+        )
+
+        tm.assert_index_equal(result.index, expected)
+
+    def test_sort_index_nan_multiindex(self):
+        # GH#14784
+        # incorrect sorting w.r.t. nans
+        tuples = [[12, 13], [np.nan, np.nan], [np.nan, 3], [1, 2]]
+        mi = MultiIndex.from_tuples(tuples)
+
+        df = DataFrame(np.arange(16).reshape(4, 4), index=mi, columns=list("ABCD"))
+        s = Series(np.arange(4), index=mi)
+
+        df2 = DataFrame(
+            {
+                "date": pd.DatetimeIndex(
+                    [
+                        "20121002",
+                        "20121007",
+                        "20130130",
+                        "20130202",
+                        "20130305",
+                        "20121002",
+                        "20121207",
+                        "20130130",
+                        "20130202",
+                        "20130305",
+                        "20130202",
+                        "20130305",
+                    ]
+                ),
+                "user_id": [1, 1, 1, 1, 1, 3, 3, 3, 5, 5, 5, 5],
+                "whole_cost": [
+                    1790,
+                    np.nan,
+                    280,
+                    259,
+                    np.nan,
+                    623,
+                    90,
+                    312,
+                    np.nan,
+                    301,
+                    359,
+                    801,
+                ],
+                "cost": [12, 15, 10, 24, 39, 1, 0, np.nan, 45, 34, 1, 12],
+            }
+        ).set_index(["date", "user_id"])
+
+        # sorting frame, default nan position is last
+        result = df.sort_index()
+        expected = df.iloc[[3, 0, 2, 1], :]
+        tm.assert_frame_equal(result, expected)
+
+        # sorting frame, nan position last
+        result = df.sort_index(na_position="last")
+        expected = df.iloc[[3, 0, 2, 1], :]
+        tm.assert_frame_equal(result, expected)
+
+        # sorting frame, nan position first
+        result = df.sort_index(na_position="first")
+        expected = df.iloc[[1, 2, 3, 0], :]
+        tm.assert_frame_equal(result, expected)
+
+        # sorting frame with removed rows
+        result = df2.dropna().sort_index()
+        expected = df2.sort_index().dropna()
+        tm.assert_frame_equal(result, expected)
+
+        # sorting series, default nan position is last
+        result = s.sort_index()
+        expected = s.iloc[[3, 0, 2, 1]]
+        tm.assert_series_equal(result, expected)
+
+        # sorting series, nan position last
+        result = s.sort_index(na_position="last")
+        expected = s.iloc[[3, 0, 2, 1]]
+        tm.assert_series_equal(result, expected)
+
+        # sorting series, nan position first
+        result = s.sort_index(na_position="first")
+        expected = s.iloc[[1, 2, 3, 0]]
+        tm.assert_series_equal(result, expected)
+
+    def test_sort_index_nan(self):
+        # GH#3917
+
+        # Test DataFrame with nan label
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]},
+            index=[1, 2, 3, 4, 5, 6, np.nan],
+        )
+
+        # NaN label, ascending=True, na_position='last'
+        sorted_df = df.sort_index(kind="quicksort", ascending=True, na_position="last")
+        expected = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]},
+            index=[1, 2, 3, 4, 5, 6, np.nan],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # NaN label, ascending=True, na_position='first'
+        sorted_df = df.sort_index(na_position="first")
+        expected = DataFrame(
+            {"A": [4, 1, 2, np.nan, 1, 6, 8], "B": [5, 9, np.nan, 5, 2, 5, 4]},
+            index=[np.nan, 1, 2, 3, 4, 5, 6],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # NaN label, ascending=False, na_position='last'
+        sorted_df = df.sort_index(kind="quicksort", ascending=False)
+        expected = DataFrame(
+            {"A": [8, 6, 1, np.nan, 2, 1, 4], "B": [4, 5, 2, 5, np.nan, 9, 5]},
+            index=[6, 5, 4, 3, 2, 1, np.nan],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # NaN label, ascending=False, na_position='first'
+        sorted_df = df.sort_index(
+            kind="quicksort", ascending=False, na_position="first"
+        )
+        expected = DataFrame(
+            {"A": [4, 8, 6, 1, np.nan, 2, 1], "B": [5, 4, 5, 2, 5, np.nan, 9]},
+            index=[np.nan, 6, 5, 4, 3, 2, 1],
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_index_multi_index(self):
+        # GH#25775, testing that sorting by index works with a multi-index.
+        df = DataFrame(
+            {"a": [3, 1, 2], "b": [0, 0, 0], "c": [0, 1, 2], "d": list("abc")}
+        )
+        result = df.set_index(list("abc")).sort_index(level=list("ba"))
+
+        expected = DataFrame(
+            {"a": [1, 2, 3], "b": [0, 0, 0], "c": [1, 2, 0], "d": list("bca")}
+        )
+        expected = expected.set_index(list("abc"))
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_inplace(self):
+        frame = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            index=[1, 2, 3, 4],
+            columns=["A", "B", "C", "D"],
+        )
+
+        # axis=0
+        unordered = frame.loc[[3, 2, 4, 1]]
+        a_values = unordered["A"]
+        df = unordered.copy()
+        return_value = df.sort_index(inplace=True)
+        assert return_value is None
+        expected = frame
+        tm.assert_frame_equal(df, expected)
+        # GH 44153 related
+        # Used to be a_id != id(df["A"]), but flaky in the CI
+        assert a_values is not df["A"]
+
+        df = unordered.copy()
+        return_value = df.sort_index(ascending=False, inplace=True)
+        assert return_value is None
+        expected = frame[::-1]
+        tm.assert_frame_equal(df, expected)
+
+        # axis=1
+        unordered = frame.loc[:, ["D", "B", "C", "A"]]
+        df = unordered.copy()
+        return_value = df.sort_index(axis=1, inplace=True)
+        assert return_value is None
+        expected = frame
+        tm.assert_frame_equal(df, expected)
+
+        df = unordered.copy()
+        return_value = df.sort_index(axis=1, ascending=False, inplace=True)
+        assert return_value is None
+        expected = frame.iloc[:, ::-1]
+        tm.assert_frame_equal(df, expected)
+
+    def test_sort_index_different_sortorder(self):
+        A = np.arange(20).repeat(5)
+        B = np.tile(np.arange(5), 20)
+
+        indexer = np.random.default_rng(2).permutation(100)
+        A = A.take(indexer)
+        B = B.take(indexer)
+
+        df = DataFrame(
+            {"A": A, "B": B, "C": np.random.default_rng(2).standard_normal(100)}
+        )
+
+        ex_indexer = np.lexsort((df.B.max() - df.B, df.A))
+        expected = df.take(ex_indexer)
+
+        # test with multiindex, too
+        idf = df.set_index(["A", "B"])
+
+        result = idf.sort_index(ascending=[1, 0])
+        expected = idf.take(ex_indexer)
+        tm.assert_frame_equal(result, expected)
+
+        # also, Series!
+        result = idf["C"].sort_index(ascending=[1, 0])
+        tm.assert_series_equal(result, expected["C"])
+
+    def test_sort_index_level(self):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        df = DataFrame([[1, 2], [3, 4]], mi)
+
+        result = df.sort_index(level="A", sort_remaining=False)
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=["A", "B"], sort_remaining=False)
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+        # Error thrown by sort_index when
+        # first index is sorted last (GH#26053)
+        result = df.sort_index(level=["C", "B", "A"])
+        expected = df.iloc[[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=["B", "C", "A"])
+        expected = df.iloc[[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=["C", "A"])
+        expected = df.iloc[[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_categorical_index(self):
+        df = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+                "B": Series(list("aabbca")).astype(CategoricalDtype(list("cab"))),
+            }
+        ).set_index("B")
+
+        result = df.sort_index()
+        expected = df.iloc[[4, 0, 1, 5, 2, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(ascending=False)
+        expected = df.iloc[[2, 3, 0, 1, 5, 4]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index(self):
+        # GH#13496
+
+        frame = DataFrame(
+            np.arange(16).reshape(4, 4),
+            index=[1, 2, 3, 4],
+            columns=["A", "B", "C", "D"],
+        )
+
+        # axis=0 : sort rows by index labels
+        unordered = frame.loc[[3, 2, 4, 1]]
+        result = unordered.sort_index(axis=0)
+        expected = frame
+        tm.assert_frame_equal(result, expected)
+
+        result = unordered.sort_index(ascending=False)
+        expected = frame[::-1]
+        tm.assert_frame_equal(result, expected)
+
+        # axis=1 : sort columns by column names
+        unordered = frame.iloc[:, [2, 1, 3, 0]]
+        result = unordered.sort_index(axis=1)
+        tm.assert_frame_equal(result, frame)
+
+        result = unordered.sort_index(axis=1, ascending=False)
+        expected = frame.iloc[:, ::-1]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("level", ["A", 0])  # GH#21052
+    def test_sort_index_multiindex(self, level):
+        # GH#13496
+
+        # sort rows by specified level of multi-index
+        mi = MultiIndex.from_tuples(
+            [[2, 1, 3], [2, 1, 2], [1, 1, 1]], names=list("ABC")
+        )
+        df = DataFrame([[1, 2], [3, 4], [5, 6]], index=mi)
+
+        expected_mi = MultiIndex.from_tuples(
+            [[1, 1, 1], [2, 1, 2], [2, 1, 3]], names=list("ABC")
+        )
+        expected = DataFrame([[5, 6], [3, 4], [1, 2]], index=expected_mi)
+        result = df.sort_index(level=level)
+        tm.assert_frame_equal(result, expected)
+
+        # sort_remaining=False
+        expected_mi = MultiIndex.from_tuples(
+            [[1, 1, 1], [2, 1, 3], [2, 1, 2]], names=list("ABC")
+        )
+        expected = DataFrame([[5, 6], [1, 2], [3, 4]], index=expected_mi)
+        result = df.sort_index(level=level, sort_remaining=False)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_intervalindex(self):
+        # this is a de-facto sort via unstack
+        # confirming that we sort in the order of the bins
+        y = Series(np.random.default_rng(2).standard_normal(100))
+        x1 = Series(np.sign(np.random.default_rng(2).standard_normal(100)))
+        x2 = pd.cut(
+            Series(np.random.default_rng(2).standard_normal(100)),
+            bins=[-3, -0.5, 0, 0.5, 3],
+        )
+        model = pd.concat([y, x1, x2], axis=1, keys=["Y", "X1", "X2"])
+
+        result = model.groupby(["X1", "X2"], observed=True).mean().unstack()
+        expected = IntervalIndex.from_tuples(
+            [(-3.0, -0.5), (-0.5, 0.0), (0.0, 0.5), (0.5, 3.0)], closed="right"
+        )
+        result = result.columns.levels[1].categories
+        tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_dict, sorted_dict, ascending, ignore_index, output_index",
+        [
+            ({"A": [1, 2, 3]}, {"A": [2, 3, 1]}, False, True, [0, 1, 2]),
+            ({"A": [1, 2, 3]}, {"A": [1, 3, 2]}, True, True, [0, 1, 2]),
+            ({"A": [1, 2, 3]}, {"A": [2, 3, 1]}, False, False, [5, 3, 2]),
+            ({"A": [1, 2, 3]}, {"A": [1, 3, 2]}, True, False, [2, 3, 5]),
+        ],
+    )
+    def test_sort_index_ignore_index(
+        self, inplace, original_dict, sorted_dict, ascending, ignore_index, output_index
+    ):
+        # GH 30114
+        original_index = [2, 5, 3]
+        df = DataFrame(original_dict, index=original_index)
+        expected_df = DataFrame(sorted_dict, index=output_index)
+        kwargs = {
+            "ascending": ascending,
+            "ignore_index": ignore_index,
+            "inplace": inplace,
+        }
+
+        if inplace:
+            result_df = df.copy()
+            result_df.sort_index(**kwargs)
+        else:
+            result_df = df.sort_index(**kwargs)
+
+        tm.assert_frame_equal(result_df, expected_df)
+        tm.assert_frame_equal(df, DataFrame(original_dict, index=original_index))
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("ignore_index", [True, False])
+    def test_respect_ignore_index(self, inplace, ignore_index):
+        # GH 43591
+        df = DataFrame({"a": [1, 2, 3]}, index=RangeIndex(4, -1, -2))
+        result = df.sort_index(
+            ascending=False, ignore_index=ignore_index, inplace=inplace
+        )
+
+        if inplace:
+            result = df
+        if ignore_index:
+            expected = DataFrame({"a": [1, 2, 3]})
+        else:
+            expected = DataFrame({"a": [1, 2, 3]}, index=RangeIndex(4, -1, -2))
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_dict, sorted_dict, ascending, ignore_index, output_index",
+        [
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [1, 2], "M2": [3, 4]},
+                True,
+                True,
+                [0, 1],
+            ),
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [2, 1], "M2": [4, 3]},
+                False,
+                True,
+                [0, 1],
+            ),
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [1, 2], "M2": [3, 4]},
+                True,
+                False,
+                MultiIndex.from_tuples([(2, 1), (3, 4)], names=list("AB")),
+            ),
+            (
+                {"M1": [1, 2], "M2": [3, 4]},
+                {"M1": [2, 1], "M2": [4, 3]},
+                False,
+                False,
+                MultiIndex.from_tuples([(3, 4), (2, 1)], names=list("AB")),
+            ),
+        ],
+    )
+    def test_sort_index_ignore_index_multi_index(
+        self, inplace, original_dict, sorted_dict, ascending, ignore_index, output_index
+    ):
+        # GH 30114, this is to test ignore_index on MultiIndex of index
+        mi = MultiIndex.from_tuples([(2, 1), (3, 4)], names=list("AB"))
+        df = DataFrame(original_dict, index=mi)
+        expected_df = DataFrame(sorted_dict, index=output_index)
+
+        kwargs = {
+            "ascending": ascending,
+            "ignore_index": ignore_index,
+            "inplace": inplace,
+        }
+
+        if inplace:
+            result_df = df.copy()
+            result_df.sort_index(**kwargs)
+        else:
+            result_df = df.sort_index(**kwargs)
+
+        tm.assert_frame_equal(result_df, expected_df)
+        tm.assert_frame_equal(df, DataFrame(original_dict, index=mi))
+
+    def test_sort_index_categorical_multiindex(self):
+        # GH#15058
+        df = DataFrame(
+            {
+                "a": range(6),
+                "l1": pd.Categorical(
+                    ["a", "a", "b", "b", "c", "c"],
+                    categories=["c", "a", "b"],
+                    ordered=True,
+                ),
+                "l2": [0, 1, 0, 1, 0, 1],
+            }
+        )
+        result = df.set_index(["l1", "l2"]).sort_index()
+        expected = DataFrame(
+            [4, 5, 0, 1, 2, 3],
+            columns=["a"],
+            index=MultiIndex(
+                levels=[
+                    CategoricalIndex(
+                        ["c", "a", "b"],
+                        categories=["c", "a", "b"],
+                        ordered=True,
+                        name="l1",
+                        dtype="category",
+                    ),
+                    [0, 1],
+                ],
+                codes=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+                names=["l1", "l2"],
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_and_reconstruction(self):
+        # GH#15622
+        # lexsortedness should be identical
+        # across MultiIndex construction methods
+
+        df = DataFrame([[1, 1], [2, 2]], index=list("ab"))
+        expected = DataFrame(
+            [[1, 1], [2, 2], [1, 1], [2, 2]],
+            index=MultiIndex.from_tuples(
+                [(0.5, "a"), (0.5, "b"), (0.8, "a"), (0.8, "b")]
+            ),
+        )
+        assert expected.index._is_lexsorted()
+
+        result = DataFrame(
+            [[1, 1], [2, 2], [1, 1], [2, 2]],
+            index=MultiIndex.from_product([[0.5, 0.8], list("ab")]),
+        )
+        result = result.sort_index()
+        assert result.index.is_monotonic_increasing
+
+        tm.assert_frame_equal(result, expected)
+
+        result = DataFrame(
+            [[1, 1], [2, 2], [1, 1], [2, 2]],
+            index=MultiIndex(
+                levels=[[0.5, 0.8], ["a", "b"]], codes=[[0, 0, 1, 1], [0, 1, 0, 1]]
+            ),
+        )
+        result = result.sort_index()
+        assert result.index._is_lexsorted()
+
+        tm.assert_frame_equal(result, expected)
+
+        concatted = pd.concat([df, df], keys=[0.8, 0.5])
+        result = concatted.sort_index()
+
+        assert result.index.is_monotonic_increasing
+
+        tm.assert_frame_equal(result, expected)
+
+        # GH#14015
+        df = DataFrame(
+            [[1, 2], [6, 7]],
+            columns=MultiIndex.from_tuples(
+                [(0, "20160811 12:00:00"), (0, "20160809 12:00:00")],
+                names=["l1", "Date"],
+            ),
+        )
+
+        df.columns = df.columns.set_levels(
+            pd.to_datetime(df.columns.levels[1]), level=1
+        )
+        assert not df.columns.is_monotonic_increasing
+        result = df.sort_index(axis=1)
+        assert result.columns.is_monotonic_increasing
+        result = df.sort_index(axis=1, level=1)
+        assert result.columns.is_monotonic_increasing
+
+    # TODO: better name, de-duplicate with test_sort_index_level above
+    def test_sort_index_level2(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        df = frame.copy()
+        df.index = np.arange(len(df))
+
+        # axis=1
+
+        # series
+        a_sorted = frame["A"].sort_index(level=0)
+
+        # preserve names
+        assert a_sorted.index.names == frame.index.names
+
+        # inplace
+        rs = frame.copy()
+        return_value = rs.sort_index(level=0, inplace=True)
+        assert return_value is None
+        tm.assert_frame_equal(rs, frame.sort_index(level=0))
+
+    def test_sort_index_level_large_cardinality(self):
+        # GH#2684 (int64)
+        index = MultiIndex.from_arrays([np.arange(4000)] * 3)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal(4000).astype("int64"), index=index
+        )
+
+        # it works!
+        result = df.sort_index(level=0)
+        assert result.index._lexsort_depth == 3
+
+        # GH#2684 (int32)
+        index = MultiIndex.from_arrays([np.arange(4000)] * 3)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal(4000).astype("int32"), index=index
+        )
+
+        # it works!
+        result = df.sort_index(level=0)
+        assert (result.dtypes.values == df.dtypes.values).all()
+        assert result.index._lexsort_depth == 3
+
+    def test_sort_index_level_by_name(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        frame.index.names = ["first", "second"]
+        result = frame.sort_index(level="second")
+        expected = frame.sort_index(level=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_level_mixed(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        sorted_before = frame.sort_index(level=1)
+
+        df = frame.copy()
+        df["foo"] = "bar"
+        sorted_after = df.sort_index(level=1)
+        tm.assert_frame_equal(sorted_before, sorted_after.drop(["foo"], axis=1))
+
+        dft = frame.T
+        sorted_before = dft.sort_index(level=1, axis=1)
+        dft["foo", "three"] = "bar"
+
+        sorted_after = dft.sort_index(level=1, axis=1)
+        tm.assert_frame_equal(
+            sorted_before.drop([("foo", "three")], axis=1),
+            sorted_after.drop([("foo", "three")], axis=1),
+        )
+
+    def test_sort_index_preserve_levels(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        result = frame.sort_index()
+        assert result.index.names == frame.index.names
+
+    @pytest.mark.parametrize(
+        "gen,extra",
+        [
+            ([1.0, 3.0, 2.0, 5.0], 4.0),
+            ([1, 3, 2, 5], 4),
+            (
+                [
+                    Timestamp("20130101"),
+                    Timestamp("20130103"),
+                    Timestamp("20130102"),
+                    Timestamp("20130105"),
+                ],
+                Timestamp("20130104"),
+            ),
+            (["1one", "3one", "2one", "5one"], "4one"),
+        ],
+    )
+    def test_sort_index_multilevel_repr_8017(self, gen, extra):
+        data = np.random.default_rng(2).standard_normal((3, 4))
+
+        columns = MultiIndex.from_tuples([("red", i) for i in gen])
+        df = DataFrame(data, index=list("def"), columns=columns)
+        df2 = pd.concat(
+            [
+                df,
+                DataFrame(
+                    "world",
+                    index=list("def"),
+                    columns=MultiIndex.from_tuples([("red", extra)]),
+                ),
+            ],
+            axis=1,
+        )
+
+        # check that the repr is good
+        # make sure that we have a correct sparsified repr
+        # e.g. only 1 header of read
+        assert str(df2).splitlines()[0].split() == ["red"]
+
+        # GH 8017
+        # sorting fails after columns added
+
+        # construct single-dtype then sort
+        result = df.copy().sort_index(axis=1)
+        expected = df.iloc[:, [0, 2, 1, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df2.sort_index(axis=1)
+        expected = df2.iloc[:, [0, 2, 1, 4, 3]]
+        tm.assert_frame_equal(result, expected)
+
+        # setitem then sort
+        result = df.copy()
+        result[("red", extra)] = "world"
+
+        result = result.sort_index(axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "categories",
+        [
+            pytest.param(["a", "b", "c"], id="str"),
+            pytest.param(
+                [pd.Interval(0, 1), pd.Interval(1, 2), pd.Interval(2, 3)],
+                id="pd.Interval",
+            ),
+        ],
+    )
+    def test_sort_index_with_categories(self, categories):
+        # GH#23452
+        df = DataFrame(
+            {"foo": range(len(categories))},
+            index=CategoricalIndex(
+                data=categories, categories=categories, ordered=True
+            ),
+        )
+        df.index = df.index.reorder_categories(df.index.categories[::-1])
+        result = df.sort_index()
+        expected = DataFrame(
+            {"foo": reversed(range(len(categories)))},
+            index=CategoricalIndex(
+                data=categories[::-1], categories=categories[::-1], ordered=True
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ascending",
+        [
+            None,
+            [True, None],
+            [False, "True"],
+        ],
+    )
+    def test_sort_index_ascending_bad_value_raises(self, ascending):
+        # GH 39434
+        df = DataFrame(np.arange(64))
+        length = len(df.index)
+        df.index = [(i - length / 2) % length for i in range(length)]
+        match = 'For argument "ascending" expected type bool'
+        with pytest.raises(ValueError, match=match):
+            df.sort_index(axis=0, ascending=ascending, na_position="first")
+
+    def test_sort_index_use_inf_as_na(self):
+        # GH 29687
+        expected = DataFrame(
+            {"col1": [1, 2, 3], "col2": [3, 4, 5]},
+            index=pd.date_range("2020", periods=3),
+        )
+        msg = "use_inf_as_na option is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            with pd.option_context("mode.use_inf_as_na", True):
+                result = expected.sort_index()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ascending",
+        [(True, False), [True, False]],
+    )
+    def test_sort_index_ascending_tuple(self, ascending):
+        df = DataFrame(
+            {
+                "legs": [4, 2, 4, 2, 2],
+            },
+            index=MultiIndex.from_tuples(
+                [
+                    ("mammal", "dog"),
+                    ("bird", "duck"),
+                    ("mammal", "horse"),
+                    ("bird", "penguin"),
+                    ("mammal", "kangaroo"),
+                ],
+                names=["class", "animal"],
+            ),
+        )
+
+        # parameter `ascending`` is a tuple
+        result = df.sort_index(level=(0, 1), ascending=ascending)
+
+        expected = DataFrame(
+            {
+                "legs": [2, 2, 2, 4, 4],
+            },
+            index=MultiIndex.from_tuples(
+                [
+                    ("bird", "penguin"),
+                    ("bird", "duck"),
+                    ("mammal", "kangaroo"),
+                    ("mammal", "horse"),
+                    ("mammal", "dog"),
+                ],
+                names=["class", "animal"],
+            ),
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+
+class TestDataFrameSortIndexKey:
+    def test_sort_multi_index_key(self):
+        # GH 25775, testing that sorting by index works with a multi-index.
+        df = DataFrame(
+            {"a": [3, 1, 2], "b": [0, 0, 0], "c": [0, 1, 2], "d": list("abc")}
+        ).set_index(list("abc"))
+
+        result = df.sort_index(level=list("ac"), key=lambda x: x)
+
+        expected = DataFrame(
+            {"a": [1, 2, 3], "b": [0, 0, 0], "c": [1, 2, 0], "d": list("bca")}
+        ).set_index(list("abc"))
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(level=list("ac"), key=lambda x: -x)
+        expected = DataFrame(
+            {"a": [3, 2, 1], "b": [0, 0, 0], "c": [0, 2, 1], "d": list("acb")}
+        ).set_index(list("abc"))
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_key(self):  # issue 27237
+        df = DataFrame(np.arange(6, dtype="int64"), index=list("aaBBca"))
+
+        result = df.sort_index()
+        expected = df.iloc[[2, 3, 0, 1, 5, 4]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(key=lambda x: x.str.lower())
+        expected = df.iloc[[0, 1, 5, 2, 3, 4]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(key=lambda x: x.str.lower(), ascending=False)
+        expected = df.iloc[[4, 2, 3, 0, 1, 5]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_key_int(self):
+        df = DataFrame(np.arange(6, dtype="int64"), index=np.arange(6, dtype="int64"))
+
+        result = df.sort_index()
+        tm.assert_frame_equal(result, df)
+
+        result = df.sort_index(key=lambda x: -x)
+        expected = df.sort_index(ascending=False)
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(key=lambda x: 2 * x)
+        tm.assert_frame_equal(result, df)
+
+    def test_sort_multi_index_key_str(self):
+        # GH 25775, testing that sorting by index works with a multi-index.
+        df = DataFrame(
+            {"a": ["B", "a", "C"], "b": [0, 1, 0], "c": list("abc"), "d": [0, 1, 2]}
+        ).set_index(list("abc"))
+
+        result = df.sort_index(level="a", key=lambda x: x.str.lower())
+
+        expected = DataFrame(
+            {"a": ["a", "B", "C"], "b": [1, 0, 0], "c": list("bac"), "d": [1, 0, 2]}
+        ).set_index(list("abc"))
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_index(
+            level=list("abc"),  # can refer to names
+            key=lambda x: x.str.lower() if x.name in ["a", "c"] else -x,
+        )
+
+        expected = DataFrame(
+            {"a": ["a", "B", "C"], "b": [1, 0, 0], "c": list("bac"), "d": [1, 0, 2]}
+        ).set_index(list("abc"))
+        tm.assert_frame_equal(result, expected)
+
+    def test_changes_length_raises(self):
+        df = DataFrame({"A": [1, 2, 3]})
+        with pytest.raises(ValueError, match="change the shape"):
+            df.sort_index(key=lambda x: x[:1])
+
+    def test_sort_index_multiindex_sparse_column(self):
+        # GH 29735, testing that sort_index on a multiindexed frame with sparse
+        # columns fills with 0.
+        expected = DataFrame(
+            {
+                i: pd.array([0.0, 0.0, 0.0, 0.0], dtype=pd.SparseDtype("float64", 0.0))
+                for i in range(0, 4)
+            },
+            index=MultiIndex.from_product([[1, 2], [1, 2]]),
+        )
+
+        result = expected.sort_index(level=0)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_index_na_position(self):
+        # GH#51612
+        df = DataFrame([1, 2], index=MultiIndex.from_tuples([(1, 1), (1, pd.NA)]))
+        expected = df.copy()
+        result = df.sort_index(level=[0, 1], na_position="last")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_sort_index_multiindex_sort_remaining(self, ascending):
+        # GH #24247
+        df = DataFrame(
+            {"A": [1, 2, 3, 4, 5], "B": [10, 20, 30, 40, 50]},
+            index=MultiIndex.from_tuples(
+                [("a", "x"), ("a", "y"), ("b", "x"), ("b", "y"), ("c", "x")]
+            ),
+        )
+
+        result = df.sort_index(level=1, sort_remaining=False, ascending=ascending)
+
+        if ascending:
+            expected = DataFrame(
+                {"A": [1, 3, 5, 2, 4], "B": [10, 30, 50, 20, 40]},
+                index=MultiIndex.from_tuples(
+                    [("a", "x"), ("b", "x"), ("c", "x"), ("a", "y"), ("b", "y")]
+                ),
+            )
+        else:
+            expected = DataFrame(
+                {"A": [2, 4, 1, 3, 5], "B": [20, 40, 10, 30, 50]},
+                index=MultiIndex.from_tuples(
+                    [("a", "y"), ("b", "y"), ("a", "x"), ("b", "x"), ("c", "x")]
+                ),
+            )
+
+        tm.assert_frame_equal(result, expected)
+
+
+def test_sort_index_with_sliced_multiindex():
+    # GH 55379
+    mi = MultiIndex.from_tuples(
+        [
+            ("a", "10"),
+            ("a", "18"),
+            ("a", "25"),
+            ("b", "16"),
+            ("b", "26"),
+            ("a", "45"),
+            ("b", "28"),
+            ("a", "5"),
+            ("a", "50"),
+            ("a", "51"),
+            ("b", "4"),
+        ],
+        names=["group", "str"],
+    )
+
+    df = DataFrame({"x": range(len(mi))}, index=mi)
+    result = df.iloc[0:6].sort_index()
+
+    expected = DataFrame(
+        {"x": [0, 1, 2, 5, 3, 4]},
+        index=MultiIndex.from_tuples(
+            [
+                ("a", "10"),
+                ("a", "18"),
+                ("a", "25"),
+                ("a", "45"),
+                ("b", "16"),
+                ("b", "26"),
+            ],
+            names=["group", "str"],
+        ),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sort_values.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sort_values.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd7d882f6d94a5a2d3ca046e12e5f39df369b212
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_sort_values.py
@@ -0,0 +1,940 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    NaT,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.util.version import Version
+
+
+class TestDataFrameSortValues:
+    @pytest.mark.parametrize("dtype", [np.uint8, bool])
+    def test_sort_values_sparse_no_warning(self, dtype):
+        # GH#45618
+        ser = pd.Series(Categorical(["a", "b", "a"], categories=["a", "b", "c"]))
+        df = pd.get_dummies(ser, dtype=dtype, sparse=True)
+
+        with tm.assert_produces_warning(None):
+            # No warnings about constructing Index from SparseArray
+            df.sort_values(by=df.columns.tolist())
+
+    def test_sort_values(self):
+        frame = DataFrame(
+            [[1, 1, 2], [3, 1, 0], [4, 5, 6]], index=[1, 2, 3], columns=list("ABC")
+        )
+
+        # by column (axis=0)
+        sorted_df = frame.sort_values(by="A")
+        indexer = frame["A"].argsort().values
+        expected = frame.loc[frame.index[indexer]]
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by="A", ascending=False)
+        indexer = indexer[::-1]
+        expected = frame.loc[frame.index[indexer]]
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by="A", ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # GH4839
+        sorted_df = frame.sort_values(by=["A"], ascending=[False])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # multiple bys
+        sorted_df = frame.sort_values(by=["B", "C"])
+        expected = frame.loc[[2, 1, 3]]
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=["B", "C"], ascending=False)
+        tm.assert_frame_equal(sorted_df, expected[::-1])
+
+        sorted_df = frame.sort_values(by=["B", "A"], ascending=[True, False])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            frame.sort_values(by=["A", "B"], axis=2, inplace=True)
+
+        # by row (axis=1): GH#10806
+        sorted_df = frame.sort_values(by=3, axis=1)
+        expected = frame
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=3, axis=1, ascending=False)
+        expected = frame.reindex(columns=["C", "B", "A"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=[1, 2], axis="columns")
+        expected = frame.reindex(columns=["B", "A", "C"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=[1, 3], axis=1, ascending=[True, False])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.sort_values(by=[1, 3], axis=1, ascending=False)
+        expected = frame.reindex(columns=["C", "B", "A"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        msg = r"Length of ascending \(5\) != length of by \(2\)"
+        with pytest.raises(ValueError, match=msg):
+            frame.sort_values(by=["A", "B"], axis=0, ascending=[True] * 5)
+
+    def test_sort_values_by_empty_list(self):
+        # https://github.com/pandas-dev/pandas/issues/40258
+        expected = DataFrame({"a": [1, 4, 2, 5, 3, 6]})
+        result = expected.sort_values(by=[])
+        tm.assert_frame_equal(result, expected)
+        assert result is not expected
+
+    def test_sort_values_inplace(self):
+        frame = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            index=[1, 2, 3, 4],
+            columns=["A", "B", "C", "D"],
+        )
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(by="A", inplace=True)
+        assert return_value is None
+        expected = frame.sort_values(by="A")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(by=1, axis=1, inplace=True)
+        assert return_value is None
+        expected = frame.sort_values(by=1, axis=1)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(by="A", ascending=False, inplace=True)
+        assert return_value is None
+        expected = frame.sort_values(by="A", ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(
+            by=["A", "B"], ascending=False, inplace=True
+        )
+        assert return_value is None
+        expected = frame.sort_values(by=["A", "B"], ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_multicolumn(self):
+        A = np.arange(5).repeat(20)
+        B = np.tile(np.arange(5), 20)
+        np.random.default_rng(2).shuffle(A)
+        np.random.default_rng(2).shuffle(B)
+        frame = DataFrame(
+            {"A": A, "B": B, "C": np.random.default_rng(2).standard_normal(100)}
+        )
+
+        result = frame.sort_values(by=["A", "B"])
+        indexer = np.lexsort((frame["B"], frame["A"]))
+        expected = frame.take(indexer)
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.sort_values(by=["A", "B"], ascending=False)
+        indexer = np.lexsort(
+            (frame["B"].rank(ascending=False), frame["A"].rank(ascending=False))
+        )
+        expected = frame.take(indexer)
+        tm.assert_frame_equal(result, expected)
+
+        result = frame.sort_values(by=["B", "A"])
+        indexer = np.lexsort((frame["A"], frame["B"]))
+        expected = frame.take(indexer)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_multicolumn_uint64(self):
+        # GH#9918
+        # uint64 multicolumn sort
+
+        df = DataFrame(
+            {
+                "a": pd.Series([18446637057563306014, 1162265347240853609]),
+                "b": pd.Series([1, 2]),
+            }
+        )
+        df["a"] = df["a"].astype(np.uint64)
+        result = df.sort_values(["a", "b"])
+
+        expected = DataFrame(
+            {
+                "a": pd.Series([18446637057563306014, 1162265347240853609]),
+                "b": pd.Series([1, 2]),
+            },
+            index=pd.Index([1, 0]),
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_nan(self):
+        # GH#3917
+        df = DataFrame(
+            {"A": [1, 2, np.nan, 1, 6, 8, 4], "B": [9, np.nan, 5, 2, 5, 4, 5]}
+        )
+
+        # sort one column only
+        expected = DataFrame(
+            {"A": [np.nan, 1, 1, 2, 4, 6, 8], "B": [5, 9, 2, np.nan, 5, 5, 4]},
+            index=[2, 0, 3, 1, 6, 4, 5],
+        )
+        sorted_df = df.sort_values(["A"], na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        expected = DataFrame(
+            {"A": [np.nan, 8, 6, 4, 2, 1, 1], "B": [5, 4, 5, 5, np.nan, 9, 2]},
+            index=[2, 5, 4, 6, 1, 0, 3],
+        )
+        sorted_df = df.sort_values(["A"], na_position="first", ascending=False)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        expected = df.reindex(columns=["B", "A"])
+        sorted_df = df.sort_values(by=1, axis=1, na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='last', order
+        expected = DataFrame(
+            {"A": [1, 1, 2, 4, 6, 8, np.nan], "B": [2, 9, np.nan, 5, 5, 4, 5]},
+            index=[3, 0, 1, 6, 4, 5, 2],
+        )
+        sorted_df = df.sort_values(["A", "B"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='first', order
+        expected = DataFrame(
+            {"A": [np.nan, 1, 1, 2, 4, 6, 8], "B": [5, 2, 9, np.nan, 5, 5, 4]},
+            index=[2, 3, 0, 1, 6, 4, 5],
+        )
+        sorted_df = df.sort_values(["A", "B"], na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='first', not order
+        expected = DataFrame(
+            {"A": [np.nan, 1, 1, 2, 4, 6, 8], "B": [5, 9, 2, np.nan, 5, 5, 4]},
+            index=[2, 0, 3, 1, 6, 4, 5],
+        )
+        sorted_df = df.sort_values(["A", "B"], ascending=[1, 0], na_position="first")
+        tm.assert_frame_equal(sorted_df, expected)
+
+        # na_position='last', not order
+        expected = DataFrame(
+            {"A": [8, 6, 4, 2, 1, 1, np.nan], "B": [4, 5, 5, np.nan, 2, 9, 5]},
+            index=[5, 4, 6, 1, 3, 0, 2],
+        )
+        sorted_df = df.sort_values(["A", "B"], ascending=[0, 1], na_position="last")
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_stable_descending_sort(self):
+        # GH#6399
+        df = DataFrame(
+            [[2, "first"], [2, "second"], [1, "a"], [1, "b"]],
+            columns=["sort_col", "order"],
+        )
+        sorted_df = df.sort_values(by="sort_col", kind="mergesort", ascending=False)
+        tm.assert_frame_equal(df, sorted_df)
+
+    @pytest.mark.parametrize(
+        "expected_idx_non_na, ascending",
+        [
+            [
+                [3, 4, 5, 0, 1, 8, 6, 9, 7, 10, 13, 14],
+                [True, True],
+            ],
+            [
+                [0, 3, 4, 5, 1, 8, 6, 7, 10, 13, 14, 9],
+                [True, False],
+            ],
+            [
+                [9, 7, 10, 13, 14, 6, 8, 1, 3, 4, 5, 0],
+                [False, True],
+            ],
+            [
+                [7, 10, 13, 14, 9, 6, 8, 1, 0, 3, 4, 5],
+                [False, False],
+            ],
+        ],
+    )
+    @pytest.mark.parametrize("na_position", ["first", "last"])
+    def test_sort_values_stable_multicolumn_sort(
+        self, expected_idx_non_na, ascending, na_position
+    ):
+        # GH#38426 Clarify sort_values with mult. columns / labels is stable
+        df = DataFrame(
+            {
+                "A": [1, 2, np.nan, 1, 1, 1, 6, 8, 4, 8, 8, np.nan, np.nan, 8, 8],
+                "B": [9, np.nan, 5, 2, 2, 2, 5, 4, 5, 3, 4, np.nan, np.nan, 4, 4],
+            }
+        )
+        # All rows with NaN in col "B" only have unique values in "A", therefore,
+        # only the rows with NaNs in "A" have to be treated individually:
+        expected_idx = (
+            [11, 12, 2] + expected_idx_non_na
+            if na_position == "first"
+            else expected_idx_non_na + [2, 11, 12]
+        )
+        expected = df.take(expected_idx)
+        sorted_df = df.sort_values(
+            ["A", "B"], ascending=ascending, na_position=na_position
+        )
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_stable_categorial(self):
+        # GH#16793
+        df = DataFrame({"x": Categorical(np.repeat([1, 2, 3, 4], 5), ordered=True)})
+        expected = df.copy()
+        sorted_df = df.sort_values("x", kind="mergesort")
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_datetimes(self):
+        # GH#3461, argsort / lexsort differences for a datetime column
+        df = DataFrame(
+            ["a", "a", "a", "b", "c", "d", "e", "f", "g"],
+            columns=["A"],
+            index=date_range("20130101", periods=9),
+        )
+        dts = [
+            Timestamp(x)
+            for x in [
+                "2004-02-11",
+                "2004-01-21",
+                "2004-01-26",
+                "2005-09-20",
+                "2010-10-04",
+                "2009-05-12",
+                "2008-11-12",
+                "2010-09-28",
+                "2010-09-28",
+            ]
+        ]
+        df["B"] = dts[::2] + dts[1::2]
+        df["C"] = 2.0
+        df["A1"] = 3.0
+
+        df1 = df.sort_values(by="A")
+        df2 = df.sort_values(by=["A"])
+        tm.assert_frame_equal(df1, df2)
+
+        df1 = df.sort_values(by="B")
+        df2 = df.sort_values(by=["B"])
+        tm.assert_frame_equal(df1, df2)
+
+        df1 = df.sort_values(by="B")
+
+        df2 = df.sort_values(by=["C", "B"])
+        tm.assert_frame_equal(df1, df2)
+
+    def test_sort_values_frame_column_inplace_sort_exception(
+        self, float_frame, using_copy_on_write
+    ):
+        s = float_frame["A"]
+        float_frame_orig = float_frame.copy()
+        if using_copy_on_write:
+            # INFO(CoW) Series is a new object, so can be changed inplace
+            # without modifying original datafame
+            s.sort_values(inplace=True)
+            tm.assert_series_equal(s, float_frame_orig["A"].sort_values())
+            # column in dataframe is not changed
+            tm.assert_frame_equal(float_frame, float_frame_orig)
+        else:
+            with pytest.raises(ValueError, match="This Series is a view"):
+                s.sort_values(inplace=True)
+
+        cp = s.copy()
+        cp.sort_values()  # it works!
+
+    def test_sort_values_nat_values_in_int_column(self):
+        # GH#14922: "sorting with large float and multiple columns incorrect"
+
+        # cause was that the int64 value NaT was considered as "na". Which is
+        # only correct for datetime64 columns.
+
+        int_values = (2, int(NaT._value))
+        float_values = (2.0, -1.797693e308)
+
+        df = DataFrame(
+            {"int": int_values, "float": float_values}, columns=["int", "float"]
+        )
+
+        df_reversed = DataFrame(
+            {"int": int_values[::-1], "float": float_values[::-1]},
+            columns=["int", "float"],
+            index=[1, 0],
+        )
+
+        # NaT is not a "na" for int64 columns, so na_position must not
+        # influence the result:
+        df_sorted = df.sort_values(["int", "float"], na_position="last")
+        tm.assert_frame_equal(df_sorted, df_reversed)
+
+        df_sorted = df.sort_values(["int", "float"], na_position="first")
+        tm.assert_frame_equal(df_sorted, df_reversed)
+
+        # reverse sorting order
+        df_sorted = df.sort_values(["int", "float"], ascending=False)
+        tm.assert_frame_equal(df_sorted, df)
+
+        # and now check if NaT is still considered as "na" for datetime64
+        # columns:
+        df = DataFrame(
+            {"datetime": [Timestamp("2016-01-01"), NaT], "float": float_values},
+            columns=["datetime", "float"],
+        )
+
+        df_reversed = DataFrame(
+            {"datetime": [NaT, Timestamp("2016-01-01")], "float": float_values[::-1]},
+            columns=["datetime", "float"],
+            index=[1, 0],
+        )
+
+        df_sorted = df.sort_values(["datetime", "float"], na_position="first")
+        tm.assert_frame_equal(df_sorted, df_reversed)
+
+        df_sorted = df.sort_values(["datetime", "float"], na_position="last")
+        tm.assert_frame_equal(df_sorted, df)
+
+        # Ascending should not affect the results.
+        df_sorted = df.sort_values(["datetime", "float"], ascending=False)
+        tm.assert_frame_equal(df_sorted, df)
+
+    def test_sort_nat(self):
+        # GH 16836
+
+        d1 = [Timestamp(x) for x in ["2016-01-01", "2015-01-01", np.nan, "2016-01-01"]]
+        d2 = [
+            Timestamp(x)
+            for x in ["2017-01-01", "2014-01-01", "2016-01-01", "2015-01-01"]
+        ]
+        df = DataFrame({"a": d1, "b": d2}, index=[0, 1, 2, 3])
+
+        d3 = [Timestamp(x) for x in ["2015-01-01", "2016-01-01", "2016-01-01", np.nan]]
+        d4 = [
+            Timestamp(x)
+            for x in ["2014-01-01", "2015-01-01", "2017-01-01", "2016-01-01"]
+        ]
+        expected = DataFrame({"a": d3, "b": d4}, index=[1, 3, 0, 2])
+        sorted_df = df.sort_values(by=["a", "b"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_na_position_with_categories(self):
+        # GH#22556
+        # Positioning missing value properly when column is Categorical.
+        categories = ["A", "B", "C"]
+        category_indices = [0, 2, 4]
+        list_of_nans = [np.nan, np.nan]
+        na_indices = [1, 3]
+        na_position_first = "first"
+        na_position_last = "last"
+        column_name = "c"
+
+        reversed_categories = sorted(categories, reverse=True)
+        reversed_category_indices = sorted(category_indices, reverse=True)
+        reversed_na_indices = sorted(na_indices)
+
+        df = DataFrame(
+            {
+                column_name: Categorical(
+                    ["A", np.nan, "B", np.nan, "C"], categories=categories, ordered=True
+                )
+            }
+        )
+        # sort ascending with na first
+        result = df.sort_values(
+            by=column_name, ascending=True, na_position=na_position_first
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    list_of_nans + categories, categories=categories, ordered=True
+                )
+            },
+            index=na_indices + category_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # sort ascending with na last
+        result = df.sort_values(
+            by=column_name, ascending=True, na_position=na_position_last
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    categories + list_of_nans, categories=categories, ordered=True
+                )
+            },
+            index=category_indices + na_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # sort descending with na first
+        result = df.sort_values(
+            by=column_name, ascending=False, na_position=na_position_first
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    list_of_nans + reversed_categories,
+                    categories=categories,
+                    ordered=True,
+                )
+            },
+            index=reversed_na_indices + reversed_category_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # sort descending with na last
+        result = df.sort_values(
+            by=column_name, ascending=False, na_position=na_position_last
+        )
+        expected = DataFrame(
+            {
+                column_name: Categorical(
+                    reversed_categories + list_of_nans,
+                    categories=categories,
+                    ordered=True,
+                )
+            },
+            index=reversed_category_indices + reversed_na_indices,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_nat(self):
+        # GH#16836
+
+        d1 = [Timestamp(x) for x in ["2016-01-01", "2015-01-01", np.nan, "2016-01-01"]]
+        d2 = [
+            Timestamp(x)
+            for x in ["2017-01-01", "2014-01-01", "2016-01-01", "2015-01-01"]
+        ]
+        df = DataFrame({"a": d1, "b": d2}, index=[0, 1, 2, 3])
+
+        d3 = [Timestamp(x) for x in ["2015-01-01", "2016-01-01", "2016-01-01", np.nan]]
+        d4 = [
+            Timestamp(x)
+            for x in ["2014-01-01", "2015-01-01", "2017-01-01", "2016-01-01"]
+        ]
+        expected = DataFrame({"a": d3, "b": d4}, index=[1, 3, 0, 2])
+        sorted_df = df.sort_values(by=["a", "b"])
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_na_position_with_categories_raises(self):
+        df = DataFrame(
+            {
+                "c": Categorical(
+                    ["A", np.nan, "B", np.nan, "C"],
+                    categories=["A", "B", "C"],
+                    ordered=True,
+                )
+            }
+        )
+
+        with pytest.raises(ValueError, match="invalid na_position: bad_position"):
+            df.sort_values(by="c", ascending=False, na_position="bad_position")
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_dict, sorted_dict, ignore_index, output_index",
+        [
+            ({"A": [1, 2, 3]}, {"A": [3, 2, 1]}, True, [0, 1, 2]),
+            ({"A": [1, 2, 3]}, {"A": [3, 2, 1]}, False, [2, 1, 0]),
+            (
+                {"A": [1, 2, 3], "B": [2, 3, 4]},
+                {"A": [3, 2, 1], "B": [4, 3, 2]},
+                True,
+                [0, 1, 2],
+            ),
+            (
+                {"A": [1, 2, 3], "B": [2, 3, 4]},
+                {"A": [3, 2, 1], "B": [4, 3, 2]},
+                False,
+                [2, 1, 0],
+            ),
+        ],
+    )
+    def test_sort_values_ignore_index(
+        self, inplace, original_dict, sorted_dict, ignore_index, output_index
+    ):
+        # GH 30114
+        df = DataFrame(original_dict)
+        expected = DataFrame(sorted_dict, index=output_index)
+        kwargs = {"ignore_index": ignore_index, "inplace": inplace}
+
+        if inplace:
+            result_df = df.copy()
+            result_df.sort_values("A", ascending=False, **kwargs)
+        else:
+            result_df = df.sort_values("A", ascending=False, **kwargs)
+
+        tm.assert_frame_equal(result_df, expected)
+        tm.assert_frame_equal(df, DataFrame(original_dict))
+
+    def test_sort_values_nat_na_position_default(self):
+        # GH 13230
+        expected = DataFrame(
+            {
+                "A": [1, 2, 3, 4, 4],
+                "date": pd.DatetimeIndex(
+                    [
+                        "2010-01-01 09:00:00",
+                        "2010-01-01 09:00:01",
+                        "2010-01-01 09:00:02",
+                        "2010-01-01 09:00:03",
+                        "NaT",
+                    ]
+                ),
+            }
+        )
+        result = expected.sort_values(["A", "date"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_item_cache(self, using_array_manager, using_copy_on_write):
+        # previous behavior incorrect retained an invalid _item_cache entry
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 3)), columns=["A", "B", "C"]
+        )
+        df["D"] = df["A"] * 2
+        ser = df["A"]
+        if not using_array_manager:
+            assert len(df._mgr.blocks) == 2
+
+        df.sort_values(by="A")
+
+        if using_copy_on_write:
+            ser.iloc[0] = 99
+            assert df.iloc[0, 0] == df["A"][0]
+            assert df.iloc[0, 0] != 99
+        else:
+            ser.values[0] = 99
+            assert df.iloc[0, 0] == df["A"][0]
+            assert df.iloc[0, 0] == 99
+
+    def test_sort_values_reshaping(self):
+        # GH 39426
+        values = list(range(21))
+        expected = DataFrame([values], columns=values)
+        df = expected.sort_values(expected.index[0], axis=1, ignore_index=True)
+
+        tm.assert_frame_equal(df, expected)
+
+    def test_sort_values_no_by_inplace(self):
+        # GH#50643
+        df = DataFrame({"a": [1, 2, 3]})
+        expected = df.copy()
+        result = df.sort_values(by=[], inplace=True)
+        tm.assert_frame_equal(df, expected)
+        assert result is None
+
+    def test_sort_values_no_op_reset_index(self):
+        # GH#52553
+        df = DataFrame({"A": [10, 20], "B": [1, 5]}, index=[2, 3])
+        result = df.sort_values(by="A", ignore_index=True)
+        expected = DataFrame({"A": [10, 20], "B": [1, 5]})
+        tm.assert_frame_equal(result, expected)
+
+
+class TestDataFrameSortKey:  # test key sorting (issue 27237)
+    def test_sort_values_inplace_key(self, sort_by_key):
+        frame = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)),
+            index=[1, 2, 3, 4],
+            columns=["A", "B", "C", "D"],
+        )
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(by="A", inplace=True, key=sort_by_key)
+        assert return_value is None
+        expected = frame.sort_values(by="A", key=sort_by_key)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(
+            by=1, axis=1, inplace=True, key=sort_by_key
+        )
+        assert return_value is None
+        expected = frame.sort_values(by=1, axis=1, key=sort_by_key)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        return_value = sorted_df.sort_values(
+            by="A", ascending=False, inplace=True, key=sort_by_key
+        )
+        assert return_value is None
+        expected = frame.sort_values(by="A", ascending=False, key=sort_by_key)
+        tm.assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        sorted_df.sort_values(
+            by=["A", "B"], ascending=False, inplace=True, key=sort_by_key
+        )
+        expected = frame.sort_values(by=["A", "B"], ascending=False, key=sort_by_key)
+        tm.assert_frame_equal(sorted_df, expected)
+
+    def test_sort_values_key(self):
+        df = DataFrame(np.array([0, 5, np.nan, 3, 2, np.nan]))
+
+        result = df.sort_values(0)
+        expected = df.iloc[[0, 4, 3, 1, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(0, key=lambda x: x + 5)
+        expected = df.iloc[[0, 4, 3, 1, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(0, key=lambda x: -x, ascending=False)
+        expected = df.iloc[[0, 4, 3, 1, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_by_key(self):
+        df = DataFrame(
+            {
+                "a": np.array([0, 3, np.nan, 3, 2, np.nan]),
+                "b": np.array([0, 2, np.nan, 5, 2, np.nan]),
+            }
+        )
+
+        result = df.sort_values("a", key=lambda x: -x)
+        expected = df.iloc[[1, 3, 4, 0, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(by=["a", "b"], key=lambda x: -x)
+        expected = df.iloc[[3, 1, 4, 0, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(by=["a", "b"], key=lambda x: -x, ascending=False)
+        expected = df.iloc[[0, 4, 1, 3, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_by_key_by_name(self):
+        df = DataFrame(
+            {
+                "a": np.array([0, 3, np.nan, 3, 2, np.nan]),
+                "b": np.array([0, 2, np.nan, 5, 2, np.nan]),
+            }
+        )
+
+        def key(col):
+            if col.name == "a":
+                return -col
+            else:
+                return col
+
+        result = df.sort_values(by="a", key=key)
+        expected = df.iloc[[1, 3, 4, 0, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(by=["a"], key=key)
+        expected = df.iloc[[1, 3, 4, 0, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(by="b", key=key)
+        expected = df.iloc[[0, 1, 4, 3, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(by=["a", "b"], key=key)
+        expected = df.iloc[[1, 3, 4, 0, 2, 5]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_key_string(self):
+        df = DataFrame(np.array([["hello", "goodbye"], ["hello", "Hello"]]))
+
+        result = df.sort_values(1)
+        expected = df[::-1]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values([0, 1], key=lambda col: col.str.lower())
+        tm.assert_frame_equal(result, df)
+
+        result = df.sort_values(
+            [0, 1], key=lambda col: col.str.lower(), ascending=False
+        )
+        expected = df.sort_values(1, key=lambda col: col.str.lower(), ascending=False)
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_key_empty(self, sort_by_key):
+        df = DataFrame(np.array([]))
+
+        df.sort_values(0, key=sort_by_key)
+        df.sort_index(key=sort_by_key)
+
+    def test_changes_length_raises(self):
+        df = DataFrame({"A": [1, 2, 3]})
+        with pytest.raises(ValueError, match="change the shape"):
+            df.sort_values("A", key=lambda x: x[:1])
+
+    def test_sort_values_key_axes(self):
+        df = DataFrame({0: ["Hello", "goodbye"], 1: [0, 1]})
+
+        result = df.sort_values(0, key=lambda col: col.str.lower())
+        expected = df[::-1]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(1, key=lambda col: -col)
+        expected = df[::-1]
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_key_dict_axis(self):
+        df = DataFrame({0: ["Hello", 0], 1: ["goodbye", 1]})
+
+        result = df.sort_values(0, key=lambda col: col.str.lower(), axis=1)
+        expected = df.loc[:, ::-1]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.sort_values(1, key=lambda col: -col, axis=1)
+        expected = df.loc[:, ::-1]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("ordered", [True, False])
+    def test_sort_values_key_casts_to_categorical(self, ordered):
+        # https://github.com/pandas-dev/pandas/issues/36383
+        categories = ["c", "b", "a"]
+        df = DataFrame({"x": [1, 1, 1], "y": ["a", "b", "c"]})
+
+        def sorter(key):
+            if key.name == "y":
+                return pd.Series(
+                    Categorical(key, categories=categories, ordered=ordered)
+                )
+            return key
+
+        result = df.sort_values(by=["x", "y"], key=sorter)
+        expected = DataFrame(
+            {"x": [1, 1, 1], "y": ["c", "b", "a"]}, index=pd.Index([2, 1, 0])
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.fixture
+def df_none():
+    return DataFrame(
+        {
+            "outer": ["a", "a", "a", "b", "b", "b"],
+            "inner": [1, 2, 2, 2, 1, 1],
+            "A": np.arange(6, 0, -1),
+            ("B", 5): ["one", "one", "two", "two", "one", "one"],
+        }
+    )
+
+
+@pytest.fixture(params=[["outer"], ["outer", "inner"]])
+def df_idx(request, df_none):
+    levels = request.param
+    return df_none.set_index(levels)
+
+
+@pytest.fixture(
+    params=[
+        "inner",  # index level
+        ["outer"],  # list of index level
+        "A",  # column
+        [("B", 5)],  # list of column
+        ["inner", "outer"],  # two index levels
+        [("B", 5), "outer"],  # index level and column
+        ["A", ("B", 5)],  # Two columns
+        ["inner", "outer"],  # two index levels and column
+    ]
+)
+def sort_names(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def ascending(request):
+    return request.param
+
+
+class TestSortValuesLevelAsStr:
+    def test_sort_index_level_and_column_label(
+        self, df_none, df_idx, sort_names, ascending, request
+    ):
+        # GH#14353
+        if (
+            Version(np.__version__) >= Version("1.25")
+            and request.node.callspec.id == "df_idx0-inner-True"
+        ):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        "pandas default unstable sorting of duplicates"
+                        "issue with numpy>=1.25 with AVX instructions"
+                    ),
+                    strict=False,
+                )
+            )
+
+        # Get index levels from df_idx
+        levels = df_idx.index.names
+
+        # Compute expected by sorting on columns and the setting index
+        expected = df_none.sort_values(
+            by=sort_names, ascending=ascending, axis=0
+        ).set_index(levels)
+
+        # Compute result sorting on mix on columns and index levels
+        result = df_idx.sort_values(by=sort_names, ascending=ascending, axis=0)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_column_level_and_index_label(
+        self, df_none, df_idx, sort_names, ascending, request
+    ):
+        # GH#14353
+
+        # Get levels from df_idx
+        levels = df_idx.index.names
+
+        # Compute expected by sorting on axis=0, setting index levels, and then
+        # transposing. For some cases this will result in a frame with
+        # multiple column levels
+        expected = (
+            df_none.sort_values(by=sort_names, ascending=ascending, axis=0)
+            .set_index(levels)
+            .T
+        )
+
+        # Compute result by transposing and sorting on axis=1.
+        result = df_idx.T.sort_values(by=sort_names, ascending=ascending, axis=1)
+
+        if Version(np.__version__) >= Version("1.25"):
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=(
+                        "pandas default unstable sorting of duplicates"
+                        "issue with numpy>=1.25 with AVX instructions"
+                    ),
+                    strict=False,
+                )
+            )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_values_validate_ascending_for_value_error(self):
+        # GH41634
+        df = DataFrame({"D": [23, 7, 21]})
+
+        msg = 'For argument "ascending" expected type bool, received type str.'
+        with pytest.raises(ValueError, match=msg):
+            df.sort_values(by="D", ascending="False")
+
+    @pytest.mark.parametrize("ascending", [False, 0, 1, True])
+    def test_sort_values_validate_ascending_functional(self, ascending):
+        df = DataFrame({"D": [23, 7, 21]})
+        indexer = df["D"].argsort().values
+
+        if not ascending:
+            indexer = indexer[::-1]
+
+        expected = df.loc[df.index[indexer]]
+        result = df.sort_values(by="D", ascending=ascending)
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_swapaxes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_swapaxes.py
new file mode 100644
index 0000000000000000000000000000000000000000..53a4691d48b1c7027e6e05c2050f4aa0eca4b3b4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_swapaxes.py
@@ -0,0 +1,37 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestSwapAxes:
+    def test_swapaxes(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 5)))
+        msg = "'DataFrame.swapaxes' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_frame_equal(df.T, df.swapaxes(0, 1))
+            tm.assert_frame_equal(df.T, df.swapaxes(1, 0))
+
+    def test_swapaxes_noop(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 5)))
+        msg = "'DataFrame.swapaxes' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_frame_equal(df, df.swapaxes(0, 0))
+
+    def test_swapaxes_invalid_axis(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 5)))
+        msg = "'DataFrame.swapaxes' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            msg = "No axis named 2 for object type DataFrame"
+            with pytest.raises(ValueError, match=msg):
+                df.swapaxes(2, 5)
+
+    def test_round_empty_not_input(self):
+        # GH#51032
+        df = DataFrame({"a": [1, 2]})
+        msg = "'DataFrame.swapaxes' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df.swapaxes("index", "index")
+        tm.assert_frame_equal(df, result)
+        assert df is not result
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_swaplevel.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_swaplevel.py
new file mode 100644
index 0000000000000000000000000000000000000000..5511ac7d6b1b209ba00a7414671aa7e61d403898
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_swaplevel.py
@@ -0,0 +1,36 @@
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestSwaplevel:
+    def test_swaplevel(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+
+        swapped = frame["A"].swaplevel()
+        swapped2 = frame["A"].swaplevel(0)
+        swapped3 = frame["A"].swaplevel(0, 1)
+        swapped4 = frame["A"].swaplevel("first", "second")
+        assert not swapped.index.equals(frame.index)
+        tm.assert_series_equal(swapped, swapped2)
+        tm.assert_series_equal(swapped, swapped3)
+        tm.assert_series_equal(swapped, swapped4)
+
+        back = swapped.swaplevel()
+        back2 = swapped.swaplevel(0)
+        back3 = swapped.swaplevel(0, 1)
+        back4 = swapped.swaplevel("second", "first")
+        assert back.index.equals(frame.index)
+        tm.assert_series_equal(back, back2)
+        tm.assert_series_equal(back, back3)
+        tm.assert_series_equal(back, back4)
+
+        ft = frame.T
+        swapped = ft.swaplevel("first", "second", axis=1)
+        exp = frame.swaplevel("first", "second").T
+        tm.assert_frame_equal(swapped, exp)
+
+        msg = "Can only swap levels on a hierarchical axis."
+        with pytest.raises(TypeError, match=msg):
+            DataFrame(range(3)).swaplevel()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_csv.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_csv.py
new file mode 100644
index 0000000000000000000000000000000000000000..294da02e259b7d52d06b1c4f81ab90248a692ba2
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_csv.py
@@ -0,0 +1,1331 @@
+import csv
+from io import StringIO
+import os
+
+import numpy as np
+import pytest
+
+from pandas.errors import ParserError
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+    read_csv,
+    to_datetime,
+)
+import pandas._testing as tm
+import pandas.core.common as com
+
+from pandas.io.common import get_handle
+
+
+class TestDataFrameToCSV:
+    def read_csv(self, path, **kwargs):
+        params = {"index_col": 0}
+        params.update(**kwargs)
+
+        return read_csv(path, **params)
+
+    def test_to_csv_from_csv1(self, float_frame, datetime_frame):
+        with tm.ensure_clean("__tmp_to_csv_from_csv1__") as path:
+            float_frame.iloc[:5, float_frame.columns.get_loc("A")] = np.nan
+
+            float_frame.to_csv(path)
+            float_frame.to_csv(path, columns=["A", "B"])
+            float_frame.to_csv(path, header=False)
+            float_frame.to_csv(path, index=False)
+
+            # test roundtrip
+            # freq does not roundtrip
+            datetime_frame.index = datetime_frame.index._with_freq(None)
+            datetime_frame.to_csv(path)
+            recons = self.read_csv(path, parse_dates=True)
+            tm.assert_frame_equal(datetime_frame, recons)
+
+            datetime_frame.to_csv(path, index_label="index")
+            recons = self.read_csv(path, index_col=None, parse_dates=True)
+
+            assert len(recons.columns) == len(datetime_frame.columns) + 1
+
+            # no index
+            datetime_frame.to_csv(path, index=False)
+            recons = self.read_csv(path, index_col=None, parse_dates=True)
+            tm.assert_almost_equal(datetime_frame.values, recons.values)
+
+            # corner case
+            dm = DataFrame(
+                {
+                    "s1": Series(range(3), index=np.arange(3, dtype=np.int64)),
+                    "s2": Series(range(2), index=np.arange(2, dtype=np.int64)),
+                }
+            )
+            dm.to_csv(path)
+
+            recons = self.read_csv(path)
+            tm.assert_frame_equal(dm, recons)
+
+    def test_to_csv_from_csv2(self, float_frame):
+        with tm.ensure_clean("__tmp_to_csv_from_csv2__") as path:
+            # duplicate index
+            df = DataFrame(
+                np.random.default_rng(2).standard_normal((3, 3)),
+                index=["a", "a", "b"],
+                columns=["x", "y", "z"],
+            )
+            df.to_csv(path)
+            result = self.read_csv(path)
+            tm.assert_frame_equal(result, df)
+
+            midx = MultiIndex.from_tuples([("A", 1, 2), ("A", 1, 2), ("B", 1, 2)])
+            df = DataFrame(
+                np.random.default_rng(2).standard_normal((3, 3)),
+                index=midx,
+                columns=["x", "y", "z"],
+            )
+
+            df.to_csv(path)
+            result = self.read_csv(path, index_col=[0, 1, 2], parse_dates=False)
+            tm.assert_frame_equal(result, df, check_names=False)
+
+            # column aliases
+            col_aliases = Index(["AA", "X", "Y", "Z"])
+            float_frame.to_csv(path, header=col_aliases)
+
+            rs = self.read_csv(path)
+            xp = float_frame.copy()
+            xp.columns = col_aliases
+            tm.assert_frame_equal(xp, rs)
+
+            msg = "Writing 4 cols but got 2 aliases"
+            with pytest.raises(ValueError, match=msg):
+                float_frame.to_csv(path, header=["AA", "X"])
+
+    def test_to_csv_from_csv3(self):
+        with tm.ensure_clean("__tmp_to_csv_from_csv3__") as path:
+            df1 = DataFrame(np.random.default_rng(2).standard_normal((3, 1)))
+            df2 = DataFrame(np.random.default_rng(2).standard_normal((3, 1)))
+
+            df1.to_csv(path)
+            df2.to_csv(path, mode="a", header=False)
+            xp = pd.concat([df1, df2])
+            rs = read_csv(path, index_col=0)
+            rs.columns = [int(label) for label in rs.columns]
+            xp.columns = [int(label) for label in xp.columns]
+            tm.assert_frame_equal(xp, rs)
+
+    def test_to_csv_from_csv4(self):
+        with tm.ensure_clean("__tmp_to_csv_from_csv4__") as path:
+            # GH 10833 (TimedeltaIndex formatting)
+            dt = pd.Timedelta(seconds=1)
+            df = DataFrame(
+                {"dt_data": [i * dt for i in range(3)]},
+                index=Index([i * dt for i in range(3)], name="dt_index"),
+            )
+            df.to_csv(path)
+
+            result = read_csv(path, index_col="dt_index")
+            result.index = pd.to_timedelta(result.index)
+            result["dt_data"] = pd.to_timedelta(result["dt_data"])
+
+            tm.assert_frame_equal(df, result, check_index_type=True)
+
+    def test_to_csv_from_csv5(self, timezone_frame):
+        # tz, 8260
+        with tm.ensure_clean("__tmp_to_csv_from_csv5__") as path:
+            timezone_frame.to_csv(path)
+            result = read_csv(path, index_col=0, parse_dates=["A"])
+
+            converter = (
+                lambda c: to_datetime(result[c])
+                .dt.tz_convert("UTC")
+                .dt.tz_convert(timezone_frame[c].dt.tz)
+            )
+            result["B"] = converter("B")
+            result["C"] = converter("C")
+            tm.assert_frame_equal(result, timezone_frame)
+
+    def test_to_csv_cols_reordering(self):
+        # GH3454
+        chunksize = 5
+        N = int(chunksize * 2.5)
+
+        df = tm.makeCustomDataframe(N, 3)
+        cs = df.columns
+        cols = [cs[2], cs[0]]
+
+        with tm.ensure_clean() as path:
+            df.to_csv(path, columns=cols, chunksize=chunksize)
+            rs_c = read_csv(path, index_col=0)
+
+        tm.assert_frame_equal(df[cols], rs_c, check_names=False)
+
+    @pytest.mark.parametrize("cols", [None, ["b", "a"]])
+    def test_to_csv_new_dupe_cols(self, cols):
+        chunksize = 5
+        N = int(chunksize * 2.5)
+
+        # dupe cols
+        df = tm.makeCustomDataframe(N, 3)
+        df.columns = ["a", "a", "b"]
+        with tm.ensure_clean() as path:
+            df.to_csv(path, columns=cols, chunksize=chunksize)
+            rs_c = read_csv(path, index_col=0)
+
+            # we wrote them in a different order
+            # so compare them in that order
+            if cols is not None:
+                if df.columns.is_unique:
+                    rs_c.columns = cols
+                else:
+                    indexer, missing = df.columns.get_indexer_non_unique(cols)
+                    rs_c.columns = df.columns.take(indexer)
+
+                for c in cols:
+                    obj_df = df[c]
+                    obj_rs = rs_c[c]
+                    if isinstance(obj_df, Series):
+                        tm.assert_series_equal(obj_df, obj_rs)
+                    else:
+                        tm.assert_frame_equal(obj_df, obj_rs, check_names=False)
+
+            # wrote in the same order
+            else:
+                rs_c.columns = df.columns
+                tm.assert_frame_equal(df, rs_c, check_names=False)
+
+    @pytest.mark.slow
+    def test_to_csv_dtnat(self):
+        # GH3437
+        def make_dtnat_arr(n, nnat=None):
+            if nnat is None:
+                nnat = int(n * 0.1)  # 10%
+            s = list(date_range("2000", freq="5min", periods=n))
+            if nnat:
+                for i in np.random.default_rng(2).integers(0, len(s), nnat):
+                    s[i] = NaT
+                i = np.random.default_rng(2).integers(100)
+                s[-i] = NaT
+                s[i] = NaT
+            return s
+
+        chunksize = 1000
+        s1 = make_dtnat_arr(chunksize + 5)
+        s2 = make_dtnat_arr(chunksize + 5, 0)
+
+        with tm.ensure_clean("1.csv") as pth:
+            df = DataFrame({"a": s1, "b": s2})
+            df.to_csv(pth, chunksize=chunksize)
+
+            recons = self.read_csv(pth).apply(to_datetime)
+            tm.assert_frame_equal(df, recons, check_names=False)
+
+    def _return_result_expected(
+        self,
+        df,
+        chunksize,
+        r_dtype=None,
+        c_dtype=None,
+        rnlvl=None,
+        cnlvl=None,
+        dupe_col=False,
+    ):
+        kwargs = {"parse_dates": False}
+        if cnlvl:
+            if rnlvl is not None:
+                kwargs["index_col"] = list(range(rnlvl))
+            kwargs["header"] = list(range(cnlvl))
+
+            with tm.ensure_clean("__tmp_to_csv_moar__") as path:
+                df.to_csv(path, encoding="utf8", chunksize=chunksize)
+                recons = self.read_csv(path, **kwargs)
+        else:
+            kwargs["header"] = 0
+
+            with tm.ensure_clean("__tmp_to_csv_moar__") as path:
+                df.to_csv(path, encoding="utf8", chunksize=chunksize)
+                recons = self.read_csv(path, **kwargs)
+
+        def _to_uni(x):
+            if not isinstance(x, str):
+                return x.decode("utf8")
+            return x
+
+        if dupe_col:
+            # read_Csv disambiguates the columns by
+            # labeling them dupe.1,dupe.2, etc'. monkey patch columns
+            recons.columns = df.columns
+        if rnlvl and not cnlvl:
+            delta_lvl = [recons.iloc[:, i].values for i in range(rnlvl - 1)]
+            ix = MultiIndex.from_arrays([list(recons.index)] + delta_lvl)
+            recons.index = ix
+            recons = recons.iloc[:, rnlvl - 1 :]
+
+        type_map = {"i": "i", "f": "f", "s": "O", "u": "O", "dt": "O", "p": "O"}
+        if r_dtype:
+            if r_dtype == "u":  # unicode
+                r_dtype = "O"
+                recons.index = np.array(
+                    [_to_uni(label) for label in recons.index], dtype=r_dtype
+                )
+                df.index = np.array(
+                    [_to_uni(label) for label in df.index], dtype=r_dtype
+                )
+            elif r_dtype == "dt":  # unicode
+                r_dtype = "O"
+                recons.index = np.array(
+                    [Timestamp(label) for label in recons.index], dtype=r_dtype
+                )
+                df.index = np.array(
+                    [Timestamp(label) for label in df.index], dtype=r_dtype
+                )
+            elif r_dtype == "p":
+                r_dtype = "O"
+                idx_list = to_datetime(recons.index)
+                recons.index = np.array(
+                    [Timestamp(label) for label in idx_list], dtype=r_dtype
+                )
+                df.index = np.array(
+                    list(map(Timestamp, df.index.to_timestamp())), dtype=r_dtype
+                )
+            else:
+                r_dtype = type_map.get(r_dtype)
+                recons.index = np.array(recons.index, dtype=r_dtype)
+                df.index = np.array(df.index, dtype=r_dtype)
+        if c_dtype:
+            if c_dtype == "u":
+                c_dtype = "O"
+                recons.columns = np.array(
+                    [_to_uni(label) for label in recons.columns], dtype=c_dtype
+                )
+                df.columns = np.array(
+                    [_to_uni(label) for label in df.columns], dtype=c_dtype
+                )
+            elif c_dtype == "dt":
+                c_dtype = "O"
+                recons.columns = np.array(
+                    [Timestamp(label) for label in recons.columns], dtype=c_dtype
+                )
+                df.columns = np.array(
+                    [Timestamp(label) for label in df.columns], dtype=c_dtype
+                )
+            elif c_dtype == "p":
+                c_dtype = "O"
+                col_list = to_datetime(recons.columns)
+                recons.columns = np.array(
+                    [Timestamp(label) for label in col_list], dtype=c_dtype
+                )
+                col_list = df.columns.to_timestamp()
+                df.columns = np.array(
+                    [Timestamp(label) for label in col_list], dtype=c_dtype
+                )
+            else:
+                c_dtype = type_map.get(c_dtype)
+                recons.columns = np.array(recons.columns, dtype=c_dtype)
+                df.columns = np.array(df.columns, dtype=c_dtype)
+        return df, recons
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    def test_to_csv_nrows(self, nrows):
+        df = tm.makeCustomDataframe(nrows, 4, r_idx_type="dt", c_idx_type="s")
+        result, expected = self._return_result_expected(df, 1000, "dt", "s")
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize(
+        "r_idx_type, c_idx_type", [("i", "i"), ("s", "s"), ("s", "dt"), ("p", "p")]
+    )
+    @pytest.mark.parametrize("ncols", [1, 2, 3, 4])
+    @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+    def test_to_csv_idx_types(self, nrows, r_idx_type, c_idx_type, ncols):
+        df = tm.makeCustomDataframe(
+            nrows, ncols, r_idx_type=r_idx_type, c_idx_type=c_idx_type
+        )
+        result, expected = self._return_result_expected(
+            df,
+            1000,
+            r_idx_type,
+            c_idx_type,
+        )
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [10, 98, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize("ncols", [1, 2, 3, 4])
+    def test_to_csv_idx_ncols(self, nrows, ncols):
+        df = tm.makeCustomDataframe(nrows, ncols)
+        result, expected = self._return_result_expected(df, 1000)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("nrows", [10, 98, 99, 100, 101, 102])
+    def test_to_csv_dup_cols(self, nrows):
+        df = tm.makeCustomDataframe(nrows, 3)
+        cols = list(df.columns)
+        cols[:2] = ["dupe", "dupe"]
+        cols[-2:] = ["dupe", "dupe"]
+        ix = list(df.index)
+        ix[:2] = ["rdupe", "rdupe"]
+        ix[-2:] = ["rdupe", "rdupe"]
+        df.index = ix
+        df.columns = cols
+        result, expected = self._return_result_expected(df, 1000, dupe_col=True)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    def test_to_csv_empty(self):
+        df = DataFrame(index=np.arange(10, dtype=np.int64))
+        result, expected = self._return_result_expected(df, 1000)
+        tm.assert_frame_equal(result, expected, check_column_type=False)
+
+    @pytest.mark.slow
+    def test_to_csv_chunksize(self):
+        chunksize = 1000
+        df = tm.makeCustomDataframe(chunksize // 2 + 1, 2, r_idx_nlevels=2)
+        result, expected = self._return_result_expected(df, chunksize, rnlvl=2)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "nrows", [2, 10, 99, 100, 101, 102, 198, 199, 200, 201, 202, 249, 250, 251]
+    )
+    @pytest.mark.parametrize("ncols", [2, 3, 4])
+    @pytest.mark.parametrize(
+        "df_params, func_params",
+        [
+            [{"r_idx_nlevels": 2}, {"rnlvl": 2}],
+            [{"c_idx_nlevels": 2}, {"cnlvl": 2}],
+            [{"r_idx_nlevels": 2, "c_idx_nlevels": 2}, {"rnlvl": 2, "cnlvl": 2}],
+        ],
+    )
+    def test_to_csv_params(self, nrows, df_params, func_params, ncols):
+        df = tm.makeCustomDataframe(nrows, ncols, **df_params)
+        result, expected = self._return_result_expected(df, 1000, **func_params)
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+    def test_to_csv_from_csv_w_some_infs(self, float_frame):
+        # test roundtrip with inf, -inf, nan, as full columns and mix
+        float_frame["G"] = np.nan
+        f = lambda x: [np.inf, np.nan][np.random.default_rng(2).random() < 0.5]
+        float_frame["H"] = float_frame.index.map(f)
+
+        with tm.ensure_clean() as path:
+            float_frame.to_csv(path)
+            recons = self.read_csv(path)
+
+            tm.assert_frame_equal(float_frame, recons)
+            tm.assert_frame_equal(np.isinf(float_frame), np.isinf(recons))
+
+    def test_to_csv_from_csv_w_all_infs(self, float_frame):
+        # test roundtrip with inf, -inf, nan, as full columns and mix
+        float_frame["E"] = np.inf
+        float_frame["F"] = -np.inf
+
+        with tm.ensure_clean() as path:
+            float_frame.to_csv(path)
+            recons = self.read_csv(path)
+
+            tm.assert_frame_equal(float_frame, recons)
+            tm.assert_frame_equal(np.isinf(float_frame), np.isinf(recons))
+
+    def test_to_csv_no_index(self):
+        # GH 3624, after appending columns, to_csv fails
+        with tm.ensure_clean("__tmp_to_csv_no_index__") as path:
+            df = DataFrame({"c1": [1, 2, 3], "c2": [4, 5, 6]})
+            df.to_csv(path, index=False)
+            result = read_csv(path)
+            tm.assert_frame_equal(df, result)
+            df["c3"] = Series([7, 8, 9], dtype="int64")
+            df.to_csv(path, index=False)
+            result = read_csv(path)
+            tm.assert_frame_equal(df, result)
+
+    def test_to_csv_with_mix_columns(self):
+        # gh-11637: incorrect output when a mix of integer and string column
+        # names passed as columns parameter in to_csv
+
+        df = DataFrame({0: ["a", "b", "c"], 1: ["aa", "bb", "cc"]})
+        df["test"] = "txt"
+        assert df.to_csv() == df.to_csv(columns=[0, 1, "test"])
+
+    def test_to_csv_headers(self):
+        # GH6186, the presence or absence of `index` incorrectly
+        # causes to_csv to have different header semantics.
+        from_df = DataFrame([[1, 2], [3, 4]], columns=["A", "B"])
+        to_df = DataFrame([[1, 2], [3, 4]], columns=["X", "Y"])
+        with tm.ensure_clean("__tmp_to_csv_headers__") as path:
+            from_df.to_csv(path, header=["X", "Y"])
+            recons = self.read_csv(path)
+
+            tm.assert_frame_equal(to_df, recons)
+
+            from_df.to_csv(path, index=False, header=["X", "Y"])
+            recons = self.read_csv(path)
+
+            return_value = recons.reset_index(inplace=True)
+            assert return_value is None
+            tm.assert_frame_equal(to_df, recons)
+
+    def test_to_csv_multiindex(self, float_frame, datetime_frame):
+        frame = float_frame
+        old_index = frame.index
+        arrays = np.arange(len(old_index) * 2, dtype=np.int64).reshape(2, -1)
+        new_index = MultiIndex.from_arrays(arrays, names=["first", "second"])
+        frame.index = new_index
+
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
+            frame.to_csv(path, header=False)
+            frame.to_csv(path, columns=["A", "B"])
+
+            # round trip
+            frame.to_csv(path)
+
+            df = self.read_csv(path, index_col=[0, 1], parse_dates=False)
+
+            # TODO to_csv drops column name
+            tm.assert_frame_equal(frame, df, check_names=False)
+            assert frame.index.names == df.index.names
+
+            # needed if setUp becomes a class method
+            float_frame.index = old_index
+
+            # try multiindex with dates
+            tsframe = datetime_frame
+            old_index = tsframe.index
+            new_index = [old_index, np.arange(len(old_index), dtype=np.int64)]
+            tsframe.index = MultiIndex.from_arrays(new_index)
+
+            tsframe.to_csv(path, index_label=["time", "foo"])
+            with tm.assert_produces_warning(
+                UserWarning, match="Could not infer format"
+            ):
+                recons = self.read_csv(path, index_col=[0, 1], parse_dates=True)
+
+            # TODO to_csv drops column name
+            tm.assert_frame_equal(tsframe, recons, check_names=False)
+
+            # do not load index
+            tsframe.to_csv(path)
+            recons = self.read_csv(path, index_col=None)
+            assert len(recons.columns) == len(tsframe.columns) + 2
+
+            # no index
+            tsframe.to_csv(path, index=False)
+            recons = self.read_csv(path, index_col=None)
+            tm.assert_almost_equal(recons.values, datetime_frame.values)
+
+            # needed if setUp becomes class method
+            datetime_frame.index = old_index
+
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
+            # GH3571, GH1651, GH3141
+
+            def _make_frame(names=None):
+                if names is True:
+                    names = ["first", "second"]
+                return DataFrame(
+                    np.random.default_rng(2).integers(0, 10, size=(3, 3)),
+                    columns=MultiIndex.from_tuples(
+                        [("bah", "foo"), ("bah", "bar"), ("ban", "baz")], names=names
+                    ),
+                    dtype="int64",
+                )
+
+            # column & index are multi-index
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=2, c_idx_nlevels=4)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1, 2, 3], index_col=[0, 1])
+            tm.assert_frame_equal(df, result)
+
+            # column is mi
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=1, c_idx_nlevels=4)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1, 2, 3], index_col=0)
+            tm.assert_frame_equal(df, result)
+
+            # dup column names?
+            df = tm.makeCustomDataframe(5, 3, r_idx_nlevels=3, c_idx_nlevels=4)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1, 2, 3], index_col=[0, 1, 2])
+            tm.assert_frame_equal(df, result)
+
+            # writing with no index
+            df = _make_frame()
+            df.to_csv(path, index=False)
+            result = read_csv(path, header=[0, 1])
+            tm.assert_frame_equal(df, result)
+
+            # we lose the names here
+            df = _make_frame(True)
+            df.to_csv(path, index=False)
+            result = read_csv(path, header=[0, 1])
+            assert com.all_none(*result.columns.names)
+            result.columns.names = df.columns.names
+            tm.assert_frame_equal(df, result)
+
+            # whatsnew example
+            df = _make_frame()
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1], index_col=[0])
+            tm.assert_frame_equal(df, result)
+
+            df = _make_frame(True)
+            df.to_csv(path)
+            result = read_csv(path, header=[0, 1], index_col=[0])
+            tm.assert_frame_equal(df, result)
+
+            # invalid options
+            df = _make_frame(True)
+            df.to_csv(path)
+
+            for i in [6, 7]:
+                msg = f"len of {i}, but only 5 lines in file"
+                with pytest.raises(ParserError, match=msg):
+                    read_csv(path, header=list(range(i)), index_col=0)
+
+            # write with cols
+            msg = "cannot specify cols with a MultiIndex"
+            with pytest.raises(TypeError, match=msg):
+                df.to_csv(path, columns=["foo", "bar"])
+
+        with tm.ensure_clean("__tmp_to_csv_multiindex__") as path:
+            # empty
+            tsframe[:0].to_csv(path)
+            recons = self.read_csv(path)
+
+            exp = tsframe[:0]
+            exp.index = []
+
+            tm.assert_index_equal(recons.columns, exp.columns)
+            assert len(recons) == 0
+
+    def test_to_csv_interval_index(self):
+        # GH 28210
+        df = DataFrame({"A": list("abc"), "B": range(3)}, index=pd.interval_range(0, 3))
+
+        with tm.ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
+            df.to_csv(path)
+            result = self.read_csv(path, index_col=0)
+
+            # can't roundtrip intervalindex via read_csv so check string repr (GH 23595)
+            expected = df.copy()
+            expected.index = expected.index.astype(str)
+
+            tm.assert_frame_equal(result, expected)
+
+    def test_to_csv_float32_nanrep(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1, 4)).astype(np.float32)
+        )
+        df[1] = np.nan
+
+        with tm.ensure_clean("__tmp_to_csv_float32_nanrep__.csv") as path:
+            df.to_csv(path, na_rep=999)
+
+            with open(path, encoding="utf-8") as f:
+                lines = f.readlines()
+                assert lines[1].split(",")[2] == "999"
+
+    def test_to_csv_withcommas(self):
+        # Commas inside fields should be correctly escaped when saving as CSV.
+        df = DataFrame({"A": [1, 2, 3], "B": ["5,6", "7,8", "9,0"]})
+
+        with tm.ensure_clean("__tmp_to_csv_withcommas__.csv") as path:
+            df.to_csv(path)
+            df2 = self.read_csv(path)
+            tm.assert_frame_equal(df2, df)
+
+    def test_to_csv_mixed(self):
+        def create_cols(name):
+            return [f"{name}{i:03d}" for i in range(5)]
+
+        df_float = DataFrame(
+            np.random.default_rng(2).standard_normal((100, 5)),
+            dtype="float64",
+            columns=create_cols("float"),
+        )
+        df_int = DataFrame(
+            np.random.default_rng(2).standard_normal((100, 5)).astype("int64"),
+            dtype="int64",
+            columns=create_cols("int"),
+        )
+        df_bool = DataFrame(True, index=df_float.index, columns=create_cols("bool"))
+        df_object = DataFrame(
+            "foo", index=df_float.index, columns=create_cols("object")
+        )
+        df_dt = DataFrame(
+            Timestamp("20010101").as_unit("ns"),
+            index=df_float.index,
+            columns=create_cols("date"),
+        )
+
+        # add in some nans
+        df_float.iloc[30:50, 1:3] = np.nan
+        df_dt.iloc[30:50, 1:3] = np.nan
+
+        df = pd.concat([df_float, df_int, df_bool, df_object, df_dt], axis=1)
+
+        # dtype
+        dtypes = {}
+        for n, dtype in [
+            ("float", np.float64),
+            ("int", np.int64),
+            ("bool", np.bool_),
+            ("object", object),
+        ]:
+            for c in create_cols(n):
+                dtypes[c] = dtype
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)
+            rs = read_csv(
+                filename, index_col=0, dtype=dtypes, parse_dates=create_cols("date")
+            )
+            tm.assert_frame_equal(rs, df)
+
+    def test_to_csv_dups_cols(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 30)),
+            columns=list(range(15)) + list(range(15)),
+            dtype="float64",
+        )
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)  # single dtype, fine
+            result = read_csv(filename, index_col=0)
+            result.columns = df.columns
+            tm.assert_frame_equal(result, df)
+
+        df_float = DataFrame(
+            np.random.default_rng(2).standard_normal((1000, 3)), dtype="float64"
+        )
+        df_int = DataFrame(np.random.default_rng(2).standard_normal((1000, 3))).astype(
+            "int64"
+        )
+        df_bool = DataFrame(True, index=df_float.index, columns=range(3))
+        df_object = DataFrame("foo", index=df_float.index, columns=range(3))
+        df_dt = DataFrame(
+            Timestamp("20010101").as_unit("ns"), index=df_float.index, columns=range(3)
+        )
+        df = pd.concat(
+            [df_float, df_int, df_bool, df_object, df_dt], axis=1, ignore_index=True
+        )
+
+        df.columns = [0, 1, 2] * 5
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)
+            result = read_csv(filename, index_col=0)
+
+            # date cols
+            for i in ["0.4", "1.4", "2.4"]:
+                result[i] = to_datetime(result[i])
+
+            result.columns = df.columns
+            tm.assert_frame_equal(result, df)
+
+        # GH3457
+
+        N = 10
+        df = tm.makeCustomDataframe(N, 3)
+        df.columns = ["a", "a", "b"]
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename)
+
+            # read_csv will rename the dups columns
+            result = read_csv(filename, index_col=0)
+            result = result.rename(columns={"a.1": "a"})
+            tm.assert_frame_equal(result, df)
+
+    @pytest.mark.parametrize("chunksize", [10000, 50000, 100000])
+    def test_to_csv_chunking(self, chunksize):
+        aa = DataFrame({"A": range(100000)})
+        aa["B"] = aa.A + 1.0
+        aa["C"] = aa.A + 2.0
+        aa["D"] = aa.A + 3.0
+
+        with tm.ensure_clean() as filename:
+            aa.to_csv(filename, chunksize=chunksize)
+            rs = read_csv(filename, index_col=0)
+            tm.assert_frame_equal(rs, aa)
+
+    @pytest.mark.slow
+    def test_to_csv_wide_frame_formatting(self, monkeypatch):
+        # Issue #8621
+        chunksize = 100
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((1, chunksize + 10)),
+            columns=None,
+            index=None,
+        )
+        with tm.ensure_clean() as filename:
+            with monkeypatch.context() as m:
+                m.setattr("pandas.io.formats.csvs._DEFAULT_CHUNKSIZE_CELLS", chunksize)
+                df.to_csv(filename, header=False, index=False)
+            rs = read_csv(filename, header=None)
+        tm.assert_frame_equal(rs, df)
+
+    def test_to_csv_bug(self):
+        f1 = StringIO("a,1.0\nb,2.0")
+        df = self.read_csv(f1, header=None)
+        newdf = DataFrame({"t": df[df.columns[0]]})
+
+        with tm.ensure_clean() as path:
+            newdf.to_csv(path)
+
+            recons = read_csv(path, index_col=0)
+            # don't check_names as t != 1
+            tm.assert_frame_equal(recons, newdf, check_names=False)
+
+    def test_to_csv_unicode(self):
+        df = DataFrame({"c/\u03c3": [1, 2, 3]})
+        with tm.ensure_clean() as path:
+            df.to_csv(path, encoding="UTF-8")
+            df2 = read_csv(path, index_col=0, encoding="UTF-8")
+            tm.assert_frame_equal(df, df2)
+
+            df.to_csv(path, encoding="UTF-8", index=False)
+            df2 = read_csv(path, index_col=None, encoding="UTF-8")
+            tm.assert_frame_equal(df, df2)
+
+    def test_to_csv_unicode_index_col(self):
+        buf = StringIO("")
+        df = DataFrame(
+            [["\u05d0", "d2", "d3", "d4"], ["a1", "a2", "a3", "a4"]],
+            columns=["\u05d0", "\u05d1", "\u05d2", "\u05d3"],
+            index=["\u05d0", "\u05d1"],
+        )
+
+        df.to_csv(buf, encoding="UTF-8")
+        buf.seek(0)
+
+        df2 = read_csv(buf, index_col=0, encoding="UTF-8")
+        tm.assert_frame_equal(df, df2)
+
+    def test_to_csv_stringio(self, float_frame):
+        buf = StringIO()
+        float_frame.to_csv(buf)
+        buf.seek(0)
+        recons = read_csv(buf, index_col=0)
+        tm.assert_frame_equal(recons, float_frame)
+
+    def test_to_csv_float_format(self):
+        df = DataFrame(
+            [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+            index=["A", "B"],
+            columns=["X", "Y", "Z"],
+        )
+
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename, float_format="%.2f")
+
+            rs = read_csv(filename, index_col=0)
+            xp = DataFrame(
+                [[0.12, 0.23, 0.57], [12.32, 123123.20, 321321.20]],
+                index=["A", "B"],
+                columns=["X", "Y", "Z"],
+            )
+            tm.assert_frame_equal(rs, xp)
+
+    def test_to_csv_float_format_over_decimal(self):
+        # GH#47436
+        df = DataFrame({"a": [0.5, 1.0]})
+        result = df.to_csv(
+            decimal=",",
+            float_format=lambda x: np.format_float_positional(x, trim="-"),
+            index=False,
+        )
+        expected_rows = ["a", "0.5", "1"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_unicodewriter_quoting(self):
+        df = DataFrame({"A": [1, 2, 3], "B": ["foo", "bar", "baz"]})
+
+        buf = StringIO()
+        df.to_csv(buf, index=False, quoting=csv.QUOTE_NONNUMERIC, encoding="utf-8")
+
+        result = buf.getvalue()
+        expected_rows = ['"A","B"', '1,"foo"', '2,"bar"', '3,"baz"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    @pytest.mark.parametrize("encoding", [None, "utf-8"])
+    def test_to_csv_quote_none(self, encoding):
+        # GH4328
+        df = DataFrame({"A": ["hello", '{"hello"}']})
+        buf = StringIO()
+        df.to_csv(buf, quoting=csv.QUOTE_NONE, encoding=encoding, index=False)
+
+        result = buf.getvalue()
+        expected_rows = ["A", "hello", '{"hello"}']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_index_no_leading_comma(self):
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
+
+        buf = StringIO()
+        df.to_csv(buf, index_label=False)
+
+        expected_rows = ["A,B", "one,1,4", "two,2,5", "three,3,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert buf.getvalue() == expected
+
+    def test_to_csv_lineterminators(self):
+        # see gh-20353
+        df = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["one", "two", "three"])
+
+        with tm.ensure_clean() as path:
+            # case 1: CRLF as line terminator
+            df.to_csv(path, lineterminator="\r\n")
+            expected = b",A,B\r\none,1,4\r\ntwo,2,5\r\nthree,3,6\r\n"
+
+            with open(path, mode="rb") as f:
+                assert f.read() == expected
+
+        with tm.ensure_clean() as path:
+            # case 2: LF as line terminator
+            df.to_csv(path, lineterminator="\n")
+            expected = b",A,B\none,1,4\ntwo,2,5\nthree,3,6\n"
+
+            with open(path, mode="rb") as f:
+                assert f.read() == expected
+
+        with tm.ensure_clean() as path:
+            # case 3: The default line terminator(=os.linesep)(gh-21406)
+            df.to_csv(path)
+            os_linesep = os.linesep.encode("utf-8")
+            expected = (
+                b",A,B"
+                + os_linesep
+                + b"one,1,4"
+                + os_linesep
+                + b"two,2,5"
+                + os_linesep
+                + b"three,3,6"
+                + os_linesep
+            )
+
+            with open(path, mode="rb") as f:
+                assert f.read() == expected
+
+    def test_to_csv_from_csv_categorical(self):
+        # CSV with categoricals should result in the same output
+        # as when one would add a "normal" Series/DataFrame.
+        s = Series(pd.Categorical(["a", "b", "b", "a", "a", "c", "c", "c"]))
+        s2 = Series(["a", "b", "b", "a", "a", "c", "c", "c"])
+        res = StringIO()
+
+        s.to_csv(res, header=False)
+        exp = StringIO()
+
+        s2.to_csv(exp, header=False)
+        assert res.getvalue() == exp.getvalue()
+
+        df = DataFrame({"s": s})
+        df2 = DataFrame({"s": s2})
+
+        res = StringIO()
+        df.to_csv(res)
+
+        exp = StringIO()
+        df2.to_csv(exp)
+
+        assert res.getvalue() == exp.getvalue()
+
+    def test_to_csv_path_is_none(self, float_frame):
+        # GH 8215
+        # Make sure we return string for consistency with
+        # Series.to_csv()
+        csv_str = float_frame.to_csv(path_or_buf=None)
+        assert isinstance(csv_str, str)
+        recons = read_csv(StringIO(csv_str), index_col=0)
+        tm.assert_frame_equal(float_frame, recons)
+
+    @pytest.mark.parametrize(
+        "df,encoding",
+        [
+            (
+                DataFrame(
+                    [[0.123456, 0.234567, 0.567567], [12.32112, 123123.2, 321321.2]],
+                    index=["A", "B"],
+                    columns=["X", "Y", "Z"],
+                ),
+                None,
+            ),
+            # GH 21241, 21118
+            (DataFrame([["abc", "def", "ghi"]], columns=["X", "Y", "Z"]), "ascii"),
+            (DataFrame(5 * [[123, "你好", "世界"]], columns=["X", "Y", "Z"]), "gb2312"),
+            (
+                DataFrame(
+                    5 * [[123, "Γειά σου", "Κόσμε"]],  # noqa: RUF001
+                    columns=["X", "Y", "Z"],
+                ),
+                "cp737",
+            ),
+        ],
+    )
+    def test_to_csv_compression(self, df, encoding, compression):
+        with tm.ensure_clean() as filename:
+            df.to_csv(filename, compression=compression, encoding=encoding)
+            # test the round trip - to_csv -> read_csv
+            result = read_csv(
+                filename, compression=compression, index_col=0, encoding=encoding
+            )
+            tm.assert_frame_equal(df, result)
+
+            # test the round trip using file handle - to_csv -> read_csv
+            with get_handle(
+                filename, "w", compression=compression, encoding=encoding
+            ) as handles:
+                df.to_csv(handles.handle, encoding=encoding)
+                assert not handles.handle.closed
+
+            result = read_csv(
+                filename,
+                compression=compression,
+                encoding=encoding,
+                index_col=0,
+            ).squeeze("columns")
+            tm.assert_frame_equal(df, result)
+
+            # explicitly make sure file is compressed
+            with tm.decompress_file(filename, compression) as fh:
+                text = fh.read().decode(encoding or "utf8")
+                for col in df.columns:
+                    assert col in text
+
+            with tm.decompress_file(filename, compression) as fh:
+                tm.assert_frame_equal(df, read_csv(fh, index_col=0, encoding=encoding))
+
+    def test_to_csv_date_format(self, datetime_frame):
+        with tm.ensure_clean("__tmp_to_csv_date_format__") as path:
+            dt_index = datetime_frame.index
+            datetime_frame = DataFrame(
+                {"A": dt_index, "B": dt_index.shift(1)}, index=dt_index
+            )
+            datetime_frame.to_csv(path, date_format="%Y%m%d")
+
+            # Check that the data was put in the specified format
+            test = read_csv(path, index_col=0)
+
+            datetime_frame_int = datetime_frame.map(lambda x: int(x.strftime("%Y%m%d")))
+            datetime_frame_int.index = datetime_frame_int.index.map(
+                lambda x: int(x.strftime("%Y%m%d"))
+            )
+
+            tm.assert_frame_equal(test, datetime_frame_int)
+
+            datetime_frame.to_csv(path, date_format="%Y-%m-%d")
+
+            # Check that the data was put in the specified format
+            test = read_csv(path, index_col=0)
+            datetime_frame_str = datetime_frame.map(lambda x: x.strftime("%Y-%m-%d"))
+            datetime_frame_str.index = datetime_frame_str.index.map(
+                lambda x: x.strftime("%Y-%m-%d")
+            )
+
+            tm.assert_frame_equal(test, datetime_frame_str)
+
+            # Check that columns get converted
+            datetime_frame_columns = datetime_frame.T
+            datetime_frame_columns.to_csv(path, date_format="%Y%m%d")
+
+            test = read_csv(path, index_col=0)
+
+            datetime_frame_columns = datetime_frame_columns.map(
+                lambda x: int(x.strftime("%Y%m%d"))
+            )
+            # Columns don't get converted to ints by read_csv
+            datetime_frame_columns.columns = datetime_frame_columns.columns.map(
+                lambda x: x.strftime("%Y%m%d")
+            )
+
+            tm.assert_frame_equal(test, datetime_frame_columns)
+
+            # test NaTs
+            nat_index = to_datetime(
+                ["NaT"] * 10 + ["2000-01-01", "2000-01-01", "2000-01-01"]
+            )
+            nat_frame = DataFrame({"A": nat_index}, index=nat_index)
+            nat_frame.to_csv(path, date_format="%Y-%m-%d")
+
+            test = read_csv(path, parse_dates=[0, 1], index_col=0)
+
+            tm.assert_frame_equal(test, nat_frame)
+
+    @pytest.mark.parametrize("td", [pd.Timedelta(0), pd.Timedelta("10s")])
+    def test_to_csv_with_dst_transitions(self, td):
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
+            # make sure we are not failing on transitions
+            times = date_range(
+                "2013-10-26 23:00",
+                "2013-10-27 01:00",
+                tz="Europe/London",
+                freq="H",
+                ambiguous="infer",
+            )
+            i = times + td
+            i = i._with_freq(None)  # freq is not preserved by read_csv
+            time_range = np.array(range(len(i)), dtype="int64")
+            df = DataFrame({"A": time_range}, index=i)
+            df.to_csv(path, index=True)
+            # we have to reconvert the index as we
+            # don't parse the tz's
+            result = read_csv(path, index_col=0)
+            result.index = to_datetime(result.index, utc=True).tz_convert(
+                "Europe/London"
+            )
+            tm.assert_frame_equal(result, df)
+
+    def test_to_csv_with_dst_transitions_with_pickle(self):
+        # GH11619
+        idx = date_range("2015-01-01", "2015-12-31", freq="H", tz="Europe/Paris")
+        idx = idx._with_freq(None)  # freq does not round-trip
+        idx._data._freq = None  # otherwise there is trouble on unpickle
+        df = DataFrame({"values": 1, "idx": idx}, index=idx)
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
+            df.to_csv(path, index=True)
+            result = read_csv(path, index_col=0)
+            result.index = to_datetime(result.index, utc=True).tz_convert(
+                "Europe/Paris"
+            )
+            result["idx"] = to_datetime(result["idx"], utc=True).astype(
+                "datetime64[ns, Europe/Paris]"
+            )
+            tm.assert_frame_equal(result, df)
+
+        # assert working
+        df.astype(str)
+
+        with tm.ensure_clean("csv_date_format_with_dst") as path:
+            df.to_pickle(path)
+            result = pd.read_pickle(path)
+            tm.assert_frame_equal(result, df)
+
+    def test_to_csv_quoting(self):
+        df = DataFrame(
+            {
+                "c_bool": [True, False],
+                "c_float": [1.0, 3.2],
+                "c_int": [42, np.nan],
+                "c_string": ["a", "b,c"],
+            }
+        )
+
+        expected_rows = [
+            ",c_bool,c_float,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            '1,False,3.2,,"b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv()
+        assert result == expected
+
+        result = df.to_csv(quoting=None)
+        assert result == expected
+
+        expected_rows = [
+            ",c_bool,c_float,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            '1,False,3.2,,"b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv(quoting=csv.QUOTE_MINIMAL)
+        assert result == expected
+
+        expected_rows = [
+            '"","c_bool","c_float","c_int","c_string"',
+            '"0","True","1.0","42.0","a"',
+            '"1","False","3.2","","b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+
+        result = df.to_csv(quoting=csv.QUOTE_ALL)
+        assert result == expected
+
+        # see gh-12922, gh-13259: make sure changes to
+        # the formatters do not break this behaviour
+        expected_rows = [
+            '"","c_bool","c_float","c_int","c_string"',
+            '0,True,1.0,42.0,"a"',
+            '1,False,3.2,"","b,c"',
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        result = df.to_csv(quoting=csv.QUOTE_NONNUMERIC)
+        assert result == expected
+
+        msg = "need to escape, but no escapechar set"
+        with pytest.raises(csv.Error, match=msg):
+            df.to_csv(quoting=csv.QUOTE_NONE)
+
+        with pytest.raises(csv.Error, match=msg):
+            df.to_csv(quoting=csv.QUOTE_NONE, escapechar=None)
+
+        expected_rows = [
+            ",c_bool,c_float,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            "1,False,3.2,,b!,c",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        result = df.to_csv(quoting=csv.QUOTE_NONE, escapechar="!")
+        assert result == expected
+
+        expected_rows = [
+            ",c_bool,c_ffloat,c_int,c_string",
+            "0,True,1.0,42.0,a",
+            "1,False,3.2,,bf,c",
+        ]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        result = df.to_csv(quoting=csv.QUOTE_NONE, escapechar="f")
+        assert result == expected
+
+        # see gh-3503: quoting Windows line terminators
+        # presents with encoding?
+        text_rows = ["a,b,c", '1,"test \r\n",3']
+        text = tm.convert_rows_list_to_csv_str(text_rows)
+        df = read_csv(StringIO(text))
+
+        buf = StringIO()
+        df.to_csv(buf, encoding="utf-8", index=False)
+        assert buf.getvalue() == text
+
+        # xref gh-7791: make sure the quoting parameter is passed through
+        # with multi-indexes
+        df = DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]})
+        df = df.set_index(["a", "b"])
+
+        expected_rows = ['"a","b","c"', '"1","3","5"', '"2","4","6"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert df.to_csv(quoting=csv.QUOTE_ALL) == expected
+
+    def test_period_index_date_overflow(self):
+        # see gh-15982
+
+        dates = ["1990-01-01", "2000-01-01", "3005-01-01"]
+        index = pd.PeriodIndex(dates, freq="D")
+
+        df = DataFrame([4, 5, 6], index=index)
+        result = df.to_csv()
+
+        expected_rows = [",0", "1990-01-01,4", "2000-01-01,5", "3005-01-01,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+        date_format = "%m-%d-%Y"
+        result = df.to_csv(date_format=date_format)
+
+        expected_rows = [",0", "01-01-1990,4", "01-01-2000,5", "01-01-3005,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+        # Overflow with pd.NaT
+        dates = ["1990-01-01", NaT, "3005-01-01"]
+        index = pd.PeriodIndex(dates, freq="D")
+
+        df = DataFrame([4, 5, 6], index=index)
+        result = df.to_csv()
+
+        expected_rows = [",0", "1990-01-01,4", ",5", "3005-01-01,6"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_multi_index_header(self):
+        # see gh-5539
+        columns = MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1), ("b", 2)])
+        df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]])
+        df.columns = columns
+
+        header = ["a", "b", "c", "d"]
+        result = df.to_csv(header=header)
+
+        expected_rows = [",a,b,c,d", "0,1,2,3,4", "1,5,6,7,8"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_single_level_multi_index(self):
+        # see gh-26303
+        index = Index([(1,), (2,), (3,)])
+        df = DataFrame([[1, 2, 3]], columns=index)
+        df = df.reindex(columns=[(1,), (3,)])
+        expected = ",1,3\n0,1,3\n"
+        result = df.to_csv(lineterminator="\n")
+        tm.assert_almost_equal(result, expected)
+
+    def test_gz_lineend(self):
+        # GH 25311
+        df = DataFrame({"a": [1, 2]})
+        expected_rows = ["a", "1", "2"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        with tm.ensure_clean("__test_gz_lineend.csv.gz") as path:
+            df.to_csv(path, index=False)
+            with tm.decompress_file(path, compression="gzip") as f:
+                result = f.read().decode("utf-8")
+
+        assert result == expected
+
+    def test_to_csv_numpy_16_bug(self):
+        frame = DataFrame({"a": date_range("1/1/2000", periods=10)})
+
+        buf = StringIO()
+        frame.to_csv(buf)
+
+        result = buf.getvalue()
+        assert "2000-01-01" in result
+
+    def test_to_csv_na_quoting(self):
+        # GH 15891
+        # Normalize carriage return for Windows OS
+        result = (
+            DataFrame([None, None])
+            .to_csv(None, header=False, index=False, na_rep="")
+            .replace("\r\n", "\n")
+        )
+        expected = '""\n""\n'
+        assert result == expected
+
+    def test_to_csv_categorical_and_ea(self):
+        # GH#46812
+        df = DataFrame({"a": "x", "b": [1, pd.NA]})
+        df["b"] = df["b"].astype("Int16")
+        df["b"] = df["b"].astype("category")
+        result = df.to_csv()
+        expected_rows = [",a,b", "0,x,1", "1,x,"]
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
+
+    def test_to_csv_categorical_and_interval(self):
+        # GH#46297
+        df = DataFrame(
+            {
+                "a": [
+                    pd.Interval(
+                        Timestamp("2020-01-01"),
+                        Timestamp("2020-01-02"),
+                        closed="both",
+                    )
+                ]
+            }
+        )
+        df["a"] = df["a"].astype("category")
+        result = df.to_csv()
+        expected_rows = [",a", '0,"[2020-01-01, 2020-01-02]"']
+        expected = tm.convert_rows_list_to_csv_str(expected_rows)
+        assert result == expected
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_dict.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_dict.py
new file mode 100644
index 0000000000000000000000000000000000000000..1446a74b29c32b5d7773bce37d3f9c1ddf3174f2
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_dict.py
@@ -0,0 +1,496 @@
+from collections import (
+    OrderedDict,
+    defaultdict,
+)
+from datetime import datetime
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas import (
+    NA,
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameToDict:
+    def test_to_dict_timestamp(self):
+        # GH#11247
+        # split/records producing np.datetime64 rather than Timestamps
+        # on datetime64[ns] dtypes only
+
+        tsmp = Timestamp("20130101")
+        test_data = DataFrame({"A": [tsmp, tsmp], "B": [tsmp, tsmp]})
+        test_data_mixed = DataFrame({"A": [tsmp, tsmp], "B": [1, 2]})
+
+        expected_records = [{"A": tsmp, "B": tsmp}, {"A": tsmp, "B": tsmp}]
+        expected_records_mixed = [{"A": tsmp, "B": 1}, {"A": tsmp, "B": 2}]
+
+        assert test_data.to_dict(orient="records") == expected_records
+        assert test_data_mixed.to_dict(orient="records") == expected_records_mixed
+
+        expected_series = {
+            "A": Series([tsmp, tsmp], name="A"),
+            "B": Series([tsmp, tsmp], name="B"),
+        }
+        expected_series_mixed = {
+            "A": Series([tsmp, tsmp], name="A"),
+            "B": Series([1, 2], name="B"),
+        }
+
+        tm.assert_dict_equal(test_data.to_dict(orient="series"), expected_series)
+        tm.assert_dict_equal(
+            test_data_mixed.to_dict(orient="series"), expected_series_mixed
+        )
+
+        expected_split = {
+            "index": [0, 1],
+            "data": [[tsmp, tsmp], [tsmp, tsmp]],
+            "columns": ["A", "B"],
+        }
+        expected_split_mixed = {
+            "index": [0, 1],
+            "data": [[tsmp, 1], [tsmp, 2]],
+            "columns": ["A", "B"],
+        }
+
+        tm.assert_dict_equal(test_data.to_dict(orient="split"), expected_split)
+        tm.assert_dict_equal(
+            test_data_mixed.to_dict(orient="split"), expected_split_mixed
+        )
+
+    def test_to_dict_index_not_unique_with_index_orient(self):
+        # GH#22801
+        # Data loss when indexes are not unique. Raise ValueError.
+        df = DataFrame({"a": [1, 2], "b": [0.5, 0.75]}, index=["A", "A"])
+        msg = "DataFrame index must be unique for orient='index'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient="index")
+
+    def test_to_dict_invalid_orient(self):
+        df = DataFrame({"A": [0, 1]})
+        msg = "orient 'xinvalid' not understood"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient="xinvalid")
+
+    @pytest.mark.parametrize("orient", ["d", "l", "r", "sp", "s", "i"])
+    def test_to_dict_short_orient_raises(self, orient):
+        # GH#32515
+        df = DataFrame({"A": [0, 1]})
+        with pytest.raises(ValueError, match="not understood"):
+            df.to_dict(orient=orient)
+
+    @pytest.mark.parametrize("mapping", [dict, defaultdict(list), OrderedDict])
+    def test_to_dict(self, mapping):
+        # orient= should only take the listed options
+        # see GH#32515
+        test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}}
+
+        # GH#16122
+        recons_data = DataFrame(test_data).to_dict(into=mapping)
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k][k2]
+
+        recons_data = DataFrame(test_data).to_dict("list", mapping)
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k][int(k2) - 1]
+
+        recons_data = DataFrame(test_data).to_dict("series", mapping)
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k][k2]
+
+        recons_data = DataFrame(test_data).to_dict("split", mapping)
+        expected_split = {
+            "columns": ["A", "B"],
+            "index": ["1", "2", "3"],
+            "data": [[1.0, "1"], [2.0, "2"], [np.nan, "3"]],
+        }
+        tm.assert_dict_equal(recons_data, expected_split)
+
+        recons_data = DataFrame(test_data).to_dict("records", mapping)
+        expected_records = [
+            {"A": 1.0, "B": "1"},
+            {"A": 2.0, "B": "2"},
+            {"A": np.nan, "B": "3"},
+        ]
+        assert isinstance(recons_data, list)
+        assert len(recons_data) == 3
+        for left, right in zip(recons_data, expected_records):
+            tm.assert_dict_equal(left, right)
+
+        # GH#10844
+        recons_data = DataFrame(test_data).to_dict("index")
+
+        for k, v in test_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k2][k]
+
+        df = DataFrame(test_data)
+        df["duped"] = df[df.columns[0]]
+        recons_data = df.to_dict("index")
+        comp_data = test_data.copy()
+        comp_data["duped"] = comp_data[df.columns[0]]
+        for k, v in comp_data.items():
+            for k2, v2 in v.items():
+                assert v2 == recons_data[k2][k]
+
+    @pytest.mark.parametrize("mapping", [list, defaultdict, []])
+    def test_to_dict_errors(self, mapping):
+        # GH#16122
+        df = DataFrame(np.random.default_rng(2).standard_normal((3, 3)))
+        msg = "|".join(
+            [
+                "unsupported type: <class 'list'>",
+                r"to_dict\(\) only accepts initialized defaultdicts",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            df.to_dict(into=mapping)
+
+    def test_to_dict_not_unique_warning(self):
+        # GH#16927: When converting to a dict, if a column has a non-unique name
+        # it will be dropped, throwing a warning.
+        df = DataFrame([[1, 2, 3]], columns=["a", "a", "b"])
+        with tm.assert_produces_warning(UserWarning):
+            df.to_dict()
+
+    # orient - orient argument to to_dict function
+    # item_getter - function for extracting value from
+    # the resulting dict using column name and index
+    @pytest.mark.parametrize(
+        "orient,item_getter",
+        [
+            ("dict", lambda d, col, idx: d[col][idx]),
+            ("records", lambda d, col, idx: d[idx][col]),
+            ("list", lambda d, col, idx: d[col][idx]),
+            ("split", lambda d, col, idx: d["data"][idx][d["columns"].index(col)]),
+            ("index", lambda d, col, idx: d[idx][col]),
+        ],
+    )
+    def test_to_dict_box_scalars(self, orient, item_getter):
+        # GH#14216, GH#23753
+        # make sure that we are boxing properly
+        df = DataFrame({"a": [1, 2], "b": [0.1, 0.2]})
+        result = df.to_dict(orient=orient)
+        assert isinstance(item_getter(result, "a", 0), int)
+        assert isinstance(item_getter(result, "b", 0), float)
+
+    def test_to_dict_tz(self):
+        # GH#18372 When converting to dict with orient='records' columns of
+        # datetime that are tz-aware were not converted to required arrays
+        data = [
+            (datetime(2017, 11, 18, 21, 53, 0, 219225, tzinfo=pytz.utc),),
+            (datetime(2017, 11, 18, 22, 6, 30, 61810, tzinfo=pytz.utc),),
+        ]
+        df = DataFrame(list(data), columns=["d"])
+
+        result = df.to_dict(orient="records")
+        expected = [
+            {"d": Timestamp("2017-11-18 21:53:00.219225+0000", tz=pytz.utc)},
+            {"d": Timestamp("2017-11-18 22:06:30.061810+0000", tz=pytz.utc)},
+        ]
+        tm.assert_dict_equal(result[0], expected[0])
+        tm.assert_dict_equal(result[1], expected[1])
+
+    @pytest.mark.parametrize(
+        "into, expected",
+        [
+            (
+                dict,
+                {
+                    0: {"int_col": 1, "float_col": 1.0},
+                    1: {"int_col": 2, "float_col": 2.0},
+                    2: {"int_col": 3, "float_col": 3.0},
+                },
+            ),
+            (
+                OrderedDict,
+                OrderedDict(
+                    [
+                        (0, {"int_col": 1, "float_col": 1.0}),
+                        (1, {"int_col": 2, "float_col": 2.0}),
+                        (2, {"int_col": 3, "float_col": 3.0}),
+                    ]
+                ),
+            ),
+            (
+                defaultdict(dict),
+                defaultdict(
+                    dict,
+                    {
+                        0: {"int_col": 1, "float_col": 1.0},
+                        1: {"int_col": 2, "float_col": 2.0},
+                        2: {"int_col": 3, "float_col": 3.0},
+                    },
+                ),
+            ),
+        ],
+    )
+    def test_to_dict_index_dtypes(self, into, expected):
+        # GH#18580
+        # When using to_dict(orient='index') on a dataframe with int
+        # and float columns only the int columns were cast to float
+
+        df = DataFrame({"int_col": [1, 2, 3], "float_col": [1.0, 2.0, 3.0]})
+
+        result = df.to_dict(orient="index", into=into)
+        cols = ["int_col", "float_col"]
+        result = DataFrame.from_dict(result, orient="index")[cols]
+        expected = DataFrame.from_dict(expected, orient="index")[cols]
+        tm.assert_frame_equal(result, expected)
+
+    def test_to_dict_numeric_names(self):
+        # GH#24940
+        df = DataFrame({str(i): [i] for i in range(5)})
+        result = set(df.to_dict("records")[0].keys())
+        expected = set(df.columns)
+        assert result == expected
+
+    def test_to_dict_wide(self):
+        # GH#24939
+        df = DataFrame({(f"A_{i:d}"): [i] for i in range(256)})
+        result = df.to_dict("records")[0]
+        expected = {f"A_{i:d}": i for i in range(256)}
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "data,dtype",
+        (
+            ([True, True, False], bool),
+            [
+                [
+                    datetime(2018, 1, 1),
+                    datetime(2019, 2, 2),
+                    datetime(2020, 3, 3),
+                ],
+                Timestamp,
+            ],
+            [[1.0, 2.0, 3.0], float],
+            [[1, 2, 3], int],
+            [["X", "Y", "Z"], str],
+        ),
+    )
+    def test_to_dict_orient_dtype(self, data, dtype):
+        # GH22620 & GH21256
+
+        df = DataFrame({"a": data})
+        d = df.to_dict(orient="records")
+        assert all(type(record["a"]) is dtype for record in d)
+
+    @pytest.mark.parametrize(
+        "data,expected_dtype",
+        (
+            [np.uint64(2), int],
+            [np.int64(-9), int],
+            [np.float64(1.1), float],
+            [np.bool_(True), bool],
+            [np.datetime64("2005-02-25"), Timestamp],
+        ),
+    )
+    def test_to_dict_scalar_constructor_orient_dtype(self, data, expected_dtype):
+        # GH22620 & GH21256
+
+        df = DataFrame({"a": data}, index=[0])
+        d = df.to_dict(orient="records")
+        result = type(d[0]["a"])
+        assert result is expected_dtype
+
+    def test_to_dict_mixed_numeric_frame(self):
+        # GH 12859
+        df = DataFrame({"a": [1.0], "b": [9.0]})
+        result = df.reset_index().to_dict("records")
+        expected = [{"index": 0, "a": 1.0, "b": 9.0}]
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "index",
+        [
+            None,
+            Index(["aa", "bb"]),
+            Index(["aa", "bb"], name="cc"),
+            MultiIndex.from_tuples([("a", "b"), ("a", "c")]),
+            MultiIndex.from_tuples([("a", "b"), ("a", "c")], names=["n1", "n2"]),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "columns",
+        [
+            ["x", "y"],
+            Index(["x", "y"]),
+            Index(["x", "y"], name="z"),
+            MultiIndex.from_tuples([("x", 1), ("y", 2)]),
+            MultiIndex.from_tuples([("x", 1), ("y", 2)], names=["z1", "z2"]),
+        ],
+    )
+    def test_to_dict_orient_tight(self, index, columns):
+        df = DataFrame.from_records(
+            [[1, 3], [2, 4]],
+            columns=columns,
+            index=index,
+        )
+        roundtrip = DataFrame.from_dict(df.to_dict(orient="tight"), orient="tight")
+
+        tm.assert_frame_equal(df, roundtrip)
+
+    @pytest.mark.parametrize(
+        "orient",
+        ["dict", "list", "split", "records", "index", "tight"],
+    )
+    @pytest.mark.parametrize(
+        "data,expected_types",
+        (
+            (
+                {
+                    "a": [np.int64(1), 1, np.int64(3)],
+                    "b": [np.float64(1.0), 2.0, np.float64(3.0)],
+                    "c": [np.float64(1.0), 2, np.int64(3)],
+                    "d": [np.float64(1.0), "a", np.int64(3)],
+                    "e": [np.float64(1.0), ["a"], np.int64(3)],
+                    "f": [np.float64(1.0), ("a",), np.int64(3)],
+                },
+                {
+                    "a": [int, int, int],
+                    "b": [float, float, float],
+                    "c": [float, float, float],
+                    "d": [float, str, int],
+                    "e": [float, list, int],
+                    "f": [float, tuple, int],
+                },
+            ),
+            (
+                {
+                    "a": [1, 2, 3],
+                    "b": [1.1, 2.2, 3.3],
+                },
+                {
+                    "a": [int, int, int],
+                    "b": [float, float, float],
+                },
+            ),
+            (  # Make sure we have one df which is all object type cols
+                {
+                    "a": [1, "hello", 3],
+                    "b": [1.1, "world", 3.3],
+                },
+                {
+                    "a": [int, str, int],
+                    "b": [float, str, float],
+                },
+            ),
+        ),
+    )
+    def test_to_dict_returns_native_types(self, orient, data, expected_types):
+        # GH 46751
+        # Tests we get back native types for all orient types
+        df = DataFrame(data)
+        result = df.to_dict(orient)
+        if orient == "dict":
+            assertion_iterator = (
+                (i, key, value)
+                for key, index_value_map in result.items()
+                for i, value in index_value_map.items()
+            )
+        elif orient == "list":
+            assertion_iterator = (
+                (i, key, value)
+                for key, values in result.items()
+                for i, value in enumerate(values)
+            )
+        elif orient in {"split", "tight"}:
+            assertion_iterator = (
+                (i, key, result["data"][i][j])
+                for i in result["index"]
+                for j, key in enumerate(result["columns"])
+            )
+        elif orient == "records":
+            assertion_iterator = (
+                (i, key, value)
+                for i, record in enumerate(result)
+                for key, value in record.items()
+            )
+        elif orient == "index":
+            assertion_iterator = (
+                (i, key, value)
+                for i, record in result.items()
+                for key, value in record.items()
+            )
+
+        for i, key, value in assertion_iterator:
+            assert value == data[key][i]
+            assert type(value) is expected_types[key][i]
+
+    @pytest.mark.parametrize("orient", ["dict", "list", "series", "records", "index"])
+    def test_to_dict_index_false_error(self, orient):
+        # GH#46398
+        df = DataFrame({"col1": [1, 2], "col2": [3, 4]}, index=["row1", "row2"])
+        msg = "'index=False' is only valid when 'orient' is 'split' or 'tight'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient=orient, index=False)
+
+    @pytest.mark.parametrize(
+        "orient, expected",
+        [
+            ("split", {"columns": ["col1", "col2"], "data": [[1, 3], [2, 4]]}),
+            (
+                "tight",
+                {
+                    "columns": ["col1", "col2"],
+                    "data": [[1, 3], [2, 4]],
+                    "column_names": [None],
+                },
+            ),
+        ],
+    )
+    def test_to_dict_index_false(self, orient, expected):
+        # GH#46398
+        df = DataFrame({"col1": [1, 2], "col2": [3, 4]}, index=["row1", "row2"])
+        result = df.to_dict(orient=orient, index=False)
+        tm.assert_dict_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "orient, expected",
+        [
+            ("dict", {"a": {0: 1, 1: None}}),
+            ("list", {"a": [1, None]}),
+            ("split", {"index": [0, 1], "columns": ["a"], "data": [[1], [None]]}),
+            (
+                "tight",
+                {
+                    "index": [0, 1],
+                    "columns": ["a"],
+                    "data": [[1], [None]],
+                    "index_names": [None],
+                    "column_names": [None],
+                },
+            ),
+            ("records", [{"a": 1}, {"a": None}]),
+            ("index", {0: {"a": 1}, 1: {"a": None}}),
+        ],
+    )
+    def test_to_dict_na_to_none(self, orient, expected):
+        # GH#50795
+        df = DataFrame({"a": [1, NA]}, dtype="Int64")
+        result = df.to_dict(orient=orient)
+        assert result == expected
+
+    def test_to_dict_masked_native_python(self):
+        # GH#34665
+        df = DataFrame({"a": Series([1, 2], dtype="Int64"), "B": 1})
+        result = df.to_dict(orient="records")
+        assert type(result[0]["a"]) is int
+
+        df = DataFrame({"a": Series([1, NA], dtype="Int64"), "B": 1})
+        result = df.to_dict(orient="records")
+        assert type(result[0]["a"]) is int
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_dict_of_blocks.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_dict_of_blocks.py
new file mode 100644
index 0000000000000000000000000000000000000000..906e74230a762808a1823b71321e68e9f1c64e07
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_dict_of_blocks.py
@@ -0,0 +1,90 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+)
+import pandas._testing as tm
+from pandas.core.arrays import NumpyExtensionArray
+
+pytestmark = td.skip_array_manager_invalid_test
+
+
+class TestToDictOfBlocks:
+    def test_copy_blocks(self, float_frame):
+        # GH#9607
+        df = DataFrame(float_frame, copy=True)
+        column = df.columns[0]
+
+        # use the default copy=True, change a column
+        _last_df = None
+        blocks = df._to_dict_of_blocks(copy=True)
+        for _df in blocks.values():
+            _last_df = _df
+            if column in _df:
+                _df.loc[:, column] = _df[column] + 1
+
+        # make sure we did not change the original DataFrame
+        assert _last_df is not None and not _last_df[column].equals(df[column])
+
+    def test_no_copy_blocks(self, float_frame, using_copy_on_write):
+        # GH#9607
+        df = DataFrame(float_frame, copy=True)
+        column = df.columns[0]
+
+        _last_df = None
+        # use the copy=False, change a column
+        blocks = df._to_dict_of_blocks(copy=False)
+        for _df in blocks.values():
+            _last_df = _df
+            if column in _df:
+                _df.loc[:, column] = _df[column] + 1
+
+        if not using_copy_on_write:
+            # make sure we did change the original DataFrame
+            assert _last_df is not None and _last_df[column].equals(df[column])
+        else:
+            assert _last_df is not None and not _last_df[column].equals(df[column])
+
+
+def test_to_dict_of_blocks_item_cache(request, using_copy_on_write):
+    if using_copy_on_write:
+        request.node.add_marker(pytest.mark.xfail(reason="CoW - not yet implemented"))
+    # Calling to_dict_of_blocks should not poison item_cache
+    df = DataFrame({"a": [1, 2, 3, 4], "b": ["a", "b", "c", "d"]})
+    df["c"] = NumpyExtensionArray(np.array([1, 2, None, 3], dtype=object))
+    mgr = df._mgr
+    assert len(mgr.blocks) == 3  # i.e. not consolidated
+
+    ser = df["b"]  # populations item_cache["b"]
+
+    df._to_dict_of_blocks()
+
+    if using_copy_on_write:
+        # TODO(CoW) we should disallow this, so `df` doesn't get updated,
+        # this currently still updates df, so this test fails
+        ser.values[0] = "foo"
+        assert df.loc[0, "b"] == "a"
+    else:
+        # Check that the to_dict_of_blocks didn't break link between ser and df
+        ser.values[0] = "foo"
+        assert df.loc[0, "b"] == "foo"
+
+        assert df["b"] is ser
+
+
+def test_set_change_dtype_slice():
+    # GH#8850
+    cols = MultiIndex.from_tuples([("1st", "a"), ("2nd", "b"), ("3rd", "c")])
+    df = DataFrame([[1.0, 2, 3], [4.0, 5, 6]], columns=cols)
+    df["2nd"] = df["2nd"] * 2.0
+
+    blocks = df._to_dict_of_blocks()
+    assert sorted(blocks.keys()) == ["float64", "int64"]
+    tm.assert_frame_equal(
+        blocks["float64"], DataFrame([[1.0, 4.0], [4.0, 10.0]], columns=cols[:2])
+    )
+    tm.assert_frame_equal(blocks["int64"], DataFrame([[3], [6]], columns=cols[2:]))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_numpy.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdb9b2c05506124abfbdbb656fd088c5e8c1cee0
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_numpy.py
@@ -0,0 +1,49 @@
+import numpy as np
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestToNumpy:
+    def test_to_numpy(self):
+        df = DataFrame({"A": [1, 2], "B": [3, 4.5]})
+        expected = np.array([[1, 3], [2, 4.5]])
+        result = df.to_numpy()
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_to_numpy_dtype(self):
+        df = DataFrame({"A": [1, 2], "B": [3, 4.5]})
+        expected = np.array([[1, 3], [2, 4]], dtype="int64")
+        result = df.to_numpy(dtype="int64")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @td.skip_array_manager_invalid_test
+    def test_to_numpy_copy(self, using_copy_on_write):
+        arr = np.random.default_rng(2).standard_normal((4, 3))
+        df = DataFrame(arr)
+        if using_copy_on_write:
+            assert df.values.base is not arr
+            assert df.to_numpy(copy=False).base is df.values.base
+        else:
+            assert df.values.base is arr
+            assert df.to_numpy(copy=False).base is arr
+        assert df.to_numpy(copy=True).base is not arr
+
+        # we still don't want a copy when na_value=np.nan is passed,
+        #  and that can be respected because we are already numpy-float
+        if using_copy_on_write:
+            assert df.to_numpy(copy=False).base is df.values.base
+        else:
+            assert df.to_numpy(copy=False, na_value=np.nan).base is arr
+
+    def test_to_numpy_mixed_dtype_to_str(self):
+        # https://github.com/pandas-dev/pandas/issues/35455
+        df = DataFrame([[Timestamp("2020-01-01 00:00:00"), 100.0]])
+        result = df.to_numpy(dtype=str)
+        expected = np.array([["2020-01-01 00:00:00", "100.0"]], dtype=str)
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_period.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_period.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a3e6b8c0e0596cfad38bfd1e02fd1b0f34e4ddb
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_period.py
@@ -0,0 +1,89 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    PeriodIndex,
+    Series,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestToPeriod:
+    def test_to_period(self, frame_or_series):
+        K = 5
+
+        dr = date_range("1/1/2000", "1/1/2001", freq="D")
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((len(dr), K)),
+            index=dr,
+            columns=["A", "B", "C", "D", "E"],
+        )
+        obj["mix"] = "a"
+        obj = tm.get_obj(obj, frame_or_series)
+
+        pts = obj.to_period()
+        exp = obj.copy()
+        exp.index = period_range("1/1/2000", "1/1/2001")
+        tm.assert_equal(pts, exp)
+
+        pts = obj.to_period("M")
+        exp.index = exp.index.asfreq("M")
+        tm.assert_equal(pts, exp)
+
+    def test_to_period_without_freq(self, frame_or_series):
+        # GH#7606 without freq
+        idx = DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"])
+        exp_idx = PeriodIndex(
+            ["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"], freq="D"
+        )
+
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 4)), index=idx, columns=idx
+        )
+        obj = tm.get_obj(obj, frame_or_series)
+        expected = obj.copy()
+        expected.index = exp_idx
+        tm.assert_equal(obj.to_period(), expected)
+
+        if frame_or_series is DataFrame:
+            expected = obj.copy()
+            expected.columns = exp_idx
+            tm.assert_frame_equal(obj.to_period(axis=1), expected)
+
+    def test_to_period_columns(self):
+        dr = date_range("1/1/2000", "1/1/2001")
+        df = DataFrame(np.random.default_rng(2).standard_normal((len(dr), 5)), index=dr)
+        df["mix"] = "a"
+
+        df = df.T
+        pts = df.to_period(axis=1)
+        exp = df.copy()
+        exp.columns = period_range("1/1/2000", "1/1/2001")
+        tm.assert_frame_equal(pts, exp)
+
+        pts = df.to_period("M", axis=1)
+        tm.assert_index_equal(pts.columns, exp.columns.asfreq("M"))
+
+    def test_to_period_invalid_axis(self):
+        dr = date_range("1/1/2000", "1/1/2001")
+        df = DataFrame(np.random.default_rng(2).standard_normal((len(dr), 5)), index=dr)
+        df["mix"] = "a"
+
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            df.to_period(axis=2)
+
+    def test_to_period_raises(self, index, frame_or_series):
+        # https://github.com/pandas-dev/pandas/issues/33327
+        obj = Series(index=index, dtype=object)
+        if frame_or_series is DataFrame:
+            obj = obj.to_frame()
+
+        if not isinstance(index, DatetimeIndex):
+            msg = f"unsupported Type {type(index).__name__}"
+            with pytest.raises(TypeError, match=msg):
+                obj.to_period()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_records.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_records.py
new file mode 100644
index 0000000000000000000000000000000000000000..27939856503e5ddb1bbd59540d099d37dddff0e9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_records.py
@@ -0,0 +1,523 @@
+from collections import abc
+import email
+from email.parser import Parser
+
+import numpy as np
+import pytest
+
+from pandas import (
+    CategoricalDtype,
+    DataFrame,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameToRecords:
+    def test_to_records_timeseries(self):
+        index = date_range("1/1/2000", periods=10)
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)),
+            index=index,
+            columns=["a", "b", "c"],
+        )
+
+        result = df.to_records()
+        assert result["index"].dtype == "M8[ns]"
+
+        result = df.to_records(index=False)
+
+    def test_to_records_dt64(self):
+        df = DataFrame(
+            [["one", "two", "three"], ["four", "five", "six"]],
+            index=date_range("2012-01-01", "2012-01-02"),
+        )
+
+        expected = df.index.values[0]
+        result = df.to_records()["index"][0]
+        assert expected == result
+
+    def test_to_records_dt64tz_column(self):
+        # GH#32535 dont less tz in to_records
+        df = DataFrame({"A": date_range("2012-01-01", "2012-01-02", tz="US/Eastern")})
+
+        result = df.to_records()
+
+        assert result.dtype["A"] == object
+        val = result[0][1]
+        assert isinstance(val, Timestamp)
+        assert val == df.loc[0, "A"]
+
+    def test_to_records_with_multindex(self):
+        # GH#3189
+        index = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+        ]
+        data = np.zeros((8, 4))
+        df = DataFrame(data, index=index)
+        r = df.to_records(index=True)["level_0"]
+        assert "bar" in r
+        assert "one" not in r
+
+    def test_to_records_with_Mapping_type(self):
+        abc.Mapping.register(email.message.Message)
+
+        headers = Parser().parsestr(
+            "From: <user@example.com>\n"
+            "To: <someone_else@example.com>\n"
+            "Subject: Test message\n"
+            "\n"
+            "Body would go here\n"
+        )
+
+        frame = DataFrame.from_records([headers])
+        all(x in frame for x in ["Type", "Subject", "From"])
+
+    def test_to_records_floats(self):
+        df = DataFrame(np.random.default_rng(2).random((10, 10)))
+        df.to_records()
+
+    def test_to_records_index_name(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((3, 3)))
+        df.index.name = "X"
+        rs = df.to_records()
+        assert "X" in rs.dtype.fields
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((3, 3)))
+        rs = df.to_records()
+        assert "index" in rs.dtype.fields
+
+        df.index = MultiIndex.from_tuples([("a", "x"), ("a", "y"), ("b", "z")])
+        df.index.names = ["A", None]
+        result = df.to_records()
+        expected = np.rec.fromarrays(
+            [np.array(["a", "a", "b"]), np.array(["x", "y", "z"])]
+            + [np.asarray(df.iloc[:, i]) for i in range(3)],
+            dtype={
+                "names": ["A", "level_1", "0", "1", "2"],
+                "formats": [
+                    "O",
+                    "O",
+                    f"{tm.ENDIAN}f8",
+                    f"{tm.ENDIAN}f8",
+                    f"{tm.ENDIAN}f8",
+                ],
+            },
+        )
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_to_records_with_unicode_index(self):
+        # GH#13172
+        # unicode_literals conflict with to_records
+        result = DataFrame([{"a": "x", "b": "y"}]).set_index("a").to_records()
+        expected = np.rec.array([("x", "y")], dtype=[("a", "O"), ("b", "O")])
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_index_dtype(self):
+        # GH 47263: consistent data types for Index and MultiIndex
+        df = DataFrame(
+            {
+                1: date_range("2022-01-01", periods=2),
+                2: date_range("2022-01-01", periods=2),
+                3: date_range("2022-01-01", periods=2),
+            }
+        )
+
+        expected = np.rec.array(
+            [
+                ("2022-01-01", "2022-01-01", "2022-01-01"),
+                ("2022-01-02", "2022-01-02", "2022-01-02"),
+            ],
+            dtype=[
+                ("1", f"{tm.ENDIAN}M8[ns]"),
+                ("2", f"{tm.ENDIAN}M8[ns]"),
+                ("3", f"{tm.ENDIAN}M8[ns]"),
+            ],
+        )
+
+        result = df.to_records(index=False)
+        tm.assert_almost_equal(result, expected)
+
+        result = df.set_index(1).to_records(index=True)
+        tm.assert_almost_equal(result, expected)
+
+        result = df.set_index([1, 2]).to_records(index=True)
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_with_unicode_column_names(self):
+        # xref issue: https://github.com/numpy/numpy/issues/2407
+        # Issue GH#11879. to_records used to raise an exception when used
+        # with column names containing non-ascii characters in Python 2
+        result = DataFrame(data={"accented_name_é": [1.0]}).to_records()
+
+        # Note that numpy allows for unicode field names but dtypes need
+        # to be specified using dictionary instead of list of tuples.
+        expected = np.rec.array(
+            [(0, 1.0)],
+            dtype={"names": ["index", "accented_name_é"], "formats": ["=i8", "=f8"]},
+        )
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_with_categorical(self):
+        # GH#8626
+
+        # dict creation
+        df = DataFrame({"A": list("abc")}, dtype="category")
+        expected = Series(list("abc"), dtype="category", name="A")
+        tm.assert_series_equal(df["A"], expected)
+
+        # list-like creation
+        df = DataFrame(list("abc"), dtype="category")
+        expected = Series(list("abc"), dtype="category", name=0)
+        tm.assert_series_equal(df[0], expected)
+
+        # to record array
+        # this coerces
+        result = df.to_records()
+        expected = np.rec.array(
+            [(0, "a"), (1, "b"), (2, "c")], dtype=[("index", "=i8"), ("0", "O")]
+        )
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "kwargs,expected",
+        [
+            # No dtypes --> default to array dtypes.
+            (
+                {},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Should have no effect in this case.
+            (
+                {"index": True},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Column dtype applied across the board. Index unaffected.
+            (
+                {"column_dtypes": f"{tm.ENDIAN}U4"},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U4"),
+                        ("B", f"{tm.ENDIAN}U4"),
+                        ("C", f"{tm.ENDIAN}U4"),
+                    ],
+                ),
+            ),
+            # Index dtype applied across the board. Columns unaffected.
+            (
+                {"index_dtypes": f"{tm.ENDIAN}U1"},
+                np.rec.array(
+                    [("0", 1, 0.2, "a"), ("1", 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}U1"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Pass in a type instance.
+            (
+                {"column_dtypes": str},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U"),
+                        ("B", f"{tm.ENDIAN}U"),
+                        ("C", f"{tm.ENDIAN}U"),
+                    ],
+                ),
+            ),
+            # Pass in a dtype instance.
+            (
+                {"column_dtypes": np.dtype(np.str_)},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", f"{tm.ENDIAN}U"),
+                        ("B", f"{tm.ENDIAN}U"),
+                        ("C", f"{tm.ENDIAN}U"),
+                    ],
+                ),
+            ),
+            # Pass in a dictionary (name-only).
+            (
+                {
+                    "column_dtypes": {
+                        "A": np.int8,
+                        "B": np.float32,
+                        "C": f"{tm.ENDIAN}U2",
+                    }
+                },
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", f"{tm.ENDIAN}U2"),
+                    ],
+                ),
+            ),
+            # Pass in a dictionary (indices-only).
+            (
+                {"index_dtypes": {0: "int16"}},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", "i2"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Ignore index mappings if index is not True.
+            (
+                {"index": False, "index_dtypes": f"{tm.ENDIAN}U2"},
+                np.rec.array(
+                    [(1, 0.2, "a"), (2, 1.5, "bc")],
+                    dtype=[
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Non-existent names / indices in mapping should not error.
+            (
+                {"index_dtypes": {0: "int16", "not-there": "float32"}},
+                np.rec.array(
+                    [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
+                    dtype=[
+                        ("index", "i2"),
+                        ("A", f"{tm.ENDIAN}i8"),
+                        ("B", f"{tm.ENDIAN}f8"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Names / indices not in mapping default to array dtype.
+            (
+                {"column_dtypes": {"A": np.int8, "B": np.float32}},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Names / indices not in dtype mapping default to array dtype.
+            (
+                {"column_dtypes": {"A": np.dtype("int8"), "B": np.dtype("float32")}},
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}i8"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Mixture of everything.
+            (
+                {
+                    "column_dtypes": {"A": np.int8, "B": np.float32},
+                    "index_dtypes": f"{tm.ENDIAN}U2",
+                },
+                np.rec.array(
+                    [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}U2"),
+                        ("A", "i1"),
+                        ("B", f"{tm.ENDIAN}f4"),
+                        ("C", "O"),
+                    ],
+                ),
+            ),
+            # Invalid dype values.
+            (
+                {"index": False, "column_dtypes": []},
+                (ValueError, "Invalid dtype \\[\\] specified for column A"),
+            ),
+            (
+                {"index": False, "column_dtypes": {"A": "int32", "B": 5}},
+                (ValueError, "Invalid dtype 5 specified for column B"),
+            ),
+            # Numpy can't handle EA types, so check error is raised
+            (
+                {
+                    "index": False,
+                    "column_dtypes": {"A": "int32", "B": CategoricalDtype(["a", "b"])},
+                },
+                (ValueError, "Invalid dtype category specified for column B"),
+            ),
+            # Check that bad types raise
+            (
+                {"index": False, "column_dtypes": {"A": "int32", "B": "foo"}},
+                (TypeError, "data type [\"']foo[\"'] not understood"),
+            ),
+        ],
+    )
+    def test_to_records_dtype(self, kwargs, expected):
+        # see GH#18146
+        df = DataFrame({"A": [1, 2], "B": [0.2, 1.5], "C": ["a", "bc"]})
+
+        if not isinstance(expected, np.rec.recarray):
+            with pytest.raises(expected[0], match=expected[1]):
+                df.to_records(**kwargs)
+        else:
+            result = df.to_records(**kwargs)
+            tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "df,kwargs,expected",
+        [
+            # MultiIndex in the index.
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=list("abc")
+                ).set_index(["a", "b"]),
+                {"column_dtypes": "float64", "index_dtypes": {0: "int32", 1: "int8"}},
+                np.rec.array(
+                    [(1, 2, 3.0), (4, 5, 6.0), (7, 8, 9.0)],
+                    dtype=[
+                        ("a", f"{tm.ENDIAN}i4"),
+                        ("b", "i1"),
+                        ("c", f"{tm.ENDIAN}f8"),
+                    ],
+                ),
+            ),
+            # MultiIndex in the columns.
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                    columns=MultiIndex.from_tuples(
+                        [("a", "d"), ("b", "e"), ("c", "f")]
+                    ),
+                ),
+                {
+                    "column_dtypes": {0: f"{tm.ENDIAN}U1", 2: "float32"},
+                    "index_dtypes": "float32",
+                },
+                np.rec.array(
+                    [(0.0, "1", 2, 3.0), (1.0, "4", 5, 6.0), (2.0, "7", 8, 9.0)],
+                    dtype=[
+                        ("index", f"{tm.ENDIAN}f4"),
+                        ("('a', 'd')", f"{tm.ENDIAN}U1"),
+                        ("('b', 'e')", f"{tm.ENDIAN}i8"),
+                        ("('c', 'f')", f"{tm.ENDIAN}f4"),
+                    ],
+                ),
+            ),
+            # MultiIndex in both the columns and index.
+            (
+                DataFrame(
+                    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                    columns=MultiIndex.from_tuples(
+                        [("a", "d"), ("b", "e"), ("c", "f")], names=list("ab")
+                    ),
+                    index=MultiIndex.from_tuples(
+                        [("d", -4), ("d", -5), ("f", -6)], names=list("cd")
+                    ),
+                ),
+                {
+                    "column_dtypes": "float64",
+                    "index_dtypes": {0: f"{tm.ENDIAN}U2", 1: "int8"},
+                },
+                np.rec.array(
+                    [
+                        ("d", -4, 1.0, 2.0, 3.0),
+                        ("d", -5, 4.0, 5.0, 6.0),
+                        ("f", -6, 7, 8, 9.0),
+                    ],
+                    dtype=[
+                        ("c", f"{tm.ENDIAN}U2"),
+                        ("d", "i1"),
+                        ("('a', 'd')", f"{tm.ENDIAN}f8"),
+                        ("('b', 'e')", f"{tm.ENDIAN}f8"),
+                        ("('c', 'f')", f"{tm.ENDIAN}f8"),
+                    ],
+                ),
+            ),
+        ],
+    )
+    def test_to_records_dtype_mi(self, df, kwargs, expected):
+        # see GH#18146
+        result = df.to_records(**kwargs)
+        tm.assert_almost_equal(result, expected)
+
+    def test_to_records_dict_like(self):
+        # see GH#18146
+        class DictLike:
+            def __init__(self, **kwargs) -> None:
+                self.d = kwargs.copy()
+
+            def __getitem__(self, key):
+                return self.d.__getitem__(key)
+
+            def __contains__(self, key) -> bool:
+                return key in self.d
+
+            def keys(self):
+                return self.d.keys()
+
+        df = DataFrame({"A": [1, 2], "B": [0.2, 1.5], "C": ["a", "bc"]})
+
+        dtype_mappings = {
+            "column_dtypes": DictLike(A=np.int8, B=np.float32),
+            "index_dtypes": f"{tm.ENDIAN}U2",
+        }
+
+        result = df.to_records(**dtype_mappings)
+        expected = np.rec.array(
+            [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
+            dtype=[
+                ("index", f"{tm.ENDIAN}U2"),
+                ("A", "i1"),
+                ("B", f"{tm.ENDIAN}f4"),
+                ("C", "O"),
+            ],
+        )
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["UTC", "GMT", "US/Eastern"])
+    def test_to_records_datetimeindex_with_tz(self, tz):
+        # GH#13937
+        dr = date_range("2016-01-01", periods=10, freq="S", tz=tz)
+
+        df = DataFrame({"datetime": dr}, index=dr)
+
+        expected = df.to_records()
+        result = df.tz_convert("UTC").to_records()
+
+        # both converted to UTC, so they are equal
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_timestamp.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_timestamp.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f73e3d58b5167959f504bb2f486a992e17ec12c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_to_timestamp.py
@@ -0,0 +1,154 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    date_range,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+def _get_with_delta(delta, freq="A-DEC"):
+    return date_range(
+        to_datetime("1/1/2001") + delta,
+        to_datetime("12/31/2009") + delta,
+        freq=freq,
+    )
+
+
+class TestToTimestamp:
+    def test_to_timestamp(self, frame_or_series):
+        K = 5
+        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), K)),
+            index=index,
+            columns=["A", "B", "C", "D", "E"],
+        )
+        obj["mix"] = "a"
+        obj = tm.get_obj(obj, frame_or_series)
+
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
+        exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
+        result = obj.to_timestamp("D", "end")
+        tm.assert_index_equal(result.index, exp_index)
+        tm.assert_numpy_array_equal(result.values, obj.values)
+        if frame_or_series is Series:
+            assert result.name == "A"
+
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
+        result = obj.to_timestamp("D", "start")
+        tm.assert_index_equal(result.index, exp_index)
+
+        result = obj.to_timestamp(how="start")
+        tm.assert_index_equal(result.index, exp_index)
+
+        delta = timedelta(hours=23)
+        result = obj.to_timestamp("H", "end")
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "h") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        delta = timedelta(hours=23, minutes=59)
+        result = obj.to_timestamp("T", "end")
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+        result = obj.to_timestamp("S", "end")
+        delta = timedelta(hours=23, minutes=59, seconds=59)
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+
+    def test_to_timestamp_columns(self):
+        K = 5
+        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), K)),
+            index=index,
+            columns=["A", "B", "C", "D", "E"],
+        )
+        df["mix"] = "a"
+
+        # columns
+        df = df.T
+
+        exp_index = date_range("1/1/2001", end="12/31/2009", freq="A-DEC")
+        exp_index = exp_index + Timedelta(1, "D") - Timedelta(1, "ns")
+        result = df.to_timestamp("D", "end", axis=1)
+        tm.assert_index_equal(result.columns, exp_index)
+        tm.assert_numpy_array_equal(result.values, df.values)
+
+        exp_index = date_range("1/1/2001", end="1/1/2009", freq="AS-JAN")
+        result = df.to_timestamp("D", "start", axis=1)
+        tm.assert_index_equal(result.columns, exp_index)
+
+        delta = timedelta(hours=23)
+        result = df.to_timestamp("H", "end", axis=1)
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "h") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.columns, exp_index)
+
+        delta = timedelta(hours=23, minutes=59)
+        result = df.to_timestamp("T", "end", axis=1)
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "m") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.columns, exp_index)
+
+        result = df.to_timestamp("S", "end", axis=1)
+        delta = timedelta(hours=23, minutes=59, seconds=59)
+        exp_index = _get_with_delta(delta)
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.columns, exp_index)
+
+        result1 = df.to_timestamp("5t", axis=1)
+        result2 = df.to_timestamp("t", axis=1)
+        expected = date_range("2001-01-01", "2009-01-01", freq="AS")
+        assert isinstance(result1.columns, DatetimeIndex)
+        assert isinstance(result2.columns, DatetimeIndex)
+        tm.assert_numpy_array_equal(result1.columns.asi8, expected.asi8)
+        tm.assert_numpy_array_equal(result2.columns.asi8, expected.asi8)
+        # PeriodIndex.to_timestamp always use 'infer'
+        assert result1.columns.freqstr == "AS-JAN"
+        assert result2.columns.freqstr == "AS-JAN"
+
+    def test_to_timestamp_invalid_axis(self):
+        index = period_range(freq="A", start="1/1/2001", end="12/1/2009")
+        obj = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), 5)), index=index
+        )
+
+        # invalid axis
+        with pytest.raises(ValueError, match="axis"):
+            obj.to_timestamp(axis=2)
+
+    def test_to_timestamp_hourly(self, frame_or_series):
+        index = period_range(freq="H", start="1/1/2001", end="1/2/2001")
+        obj = Series(1, index=index, name="foo")
+        if frame_or_series is not Series:
+            obj = obj.to_frame()
+
+        exp_index = date_range("1/1/2001 00:59:59", end="1/2/2001 00:59:59", freq="H")
+        result = obj.to_timestamp(how="end")
+        exp_index = exp_index + Timedelta(1, "s") - Timedelta(1, "ns")
+        tm.assert_index_equal(result.index, exp_index)
+        if frame_or_series is Series:
+            assert result.name == "foo"
+
+    def test_to_timestamp_raises(self, index, frame_or_series):
+        # GH#33327
+        obj = frame_or_series(index=index, dtype=object)
+
+        if not isinstance(index, PeriodIndex):
+            msg = f"unsupported Type {type(index).__name__}"
+            with pytest.raises(TypeError, match=msg):
+                obj.to_timestamp()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_transpose.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_transpose.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ff6ea37eae184051efc6674108a6c359289d919
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_transpose.py
@@ -0,0 +1,177 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    IntervalIndex,
+    Series,
+    Timestamp,
+    date_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+class TestTranspose:
+    def test_transpose_td64_intervals(self):
+        # GH#44917
+        tdi = timedelta_range("0 Days", "3 Days")
+        ii = IntervalIndex.from_breaks(tdi)
+        ii = ii.insert(-1, np.nan)
+        df = DataFrame(ii)
+
+        result = df.T
+        expected = DataFrame({i: ii[i : i + 1] for i in range(len(ii))})
+        tm.assert_frame_equal(result, expected)
+
+    def test_transpose_empty_preserves_datetimeindex(self):
+        # GH#41382
+        df = DataFrame(index=DatetimeIndex([]))
+
+        expected = DatetimeIndex([], dtype="datetime64[ns]", freq=None)
+
+        result1 = df.T.sum().index
+        result2 = df.sum(axis=1).index
+
+        tm.assert_index_equal(result1, expected)
+        tm.assert_index_equal(result2, expected)
+
+    def test_transpose_tzaware_1col_single_tz(self):
+        # GH#26825
+        dti = date_range("2016-04-05 04:30", periods=3, tz="UTC")
+
+        df = DataFrame(dti)
+        assert (df.dtypes == dti.dtype).all()
+        res = df.T
+        assert (res.dtypes == dti.dtype).all()
+
+    def test_transpose_tzaware_2col_single_tz(self):
+        # GH#26825
+        dti = date_range("2016-04-05 04:30", periods=3, tz="UTC")
+
+        df3 = DataFrame({"A": dti, "B": dti})
+        assert (df3.dtypes == dti.dtype).all()
+        res3 = df3.T
+        assert (res3.dtypes == dti.dtype).all()
+
+    def test_transpose_tzaware_2col_mixed_tz(self):
+        # GH#26825
+        dti = date_range("2016-04-05 04:30", periods=3, tz="UTC")
+        dti2 = dti.tz_convert("US/Pacific")
+
+        df4 = DataFrame({"A": dti, "B": dti2})
+        assert (df4.dtypes == [dti.dtype, dti2.dtype]).all()
+        assert (df4.T.dtypes == object).all()
+        tm.assert_frame_equal(df4.T.T, df4.astype(object))
+
+    @pytest.mark.parametrize("tz", [None, "America/New_York"])
+    def test_transpose_preserves_dtindex_equality_with_dst(self, tz):
+        # GH#19970
+        idx = date_range("20161101", "20161130", freq="4H", tz=tz)
+        df = DataFrame({"a": range(len(idx)), "b": range(len(idx))}, index=idx)
+        result = df.T == df.T
+        expected = DataFrame(True, index=list("ab"), columns=idx)
+        tm.assert_frame_equal(result, expected)
+
+    def test_transpose_object_to_tzaware_mixed_tz(self):
+        # GH#26825
+        dti = date_range("2016-04-05 04:30", periods=3, tz="UTC")
+        dti2 = dti.tz_convert("US/Pacific")
+
+        # mixed all-tzaware dtypes
+        df2 = DataFrame([dti, dti2])
+        assert (df2.dtypes == object).all()
+        res2 = df2.T
+        assert (res2.dtypes == object).all()
+
+    def test_transpose_uint64(self, uint64_frame):
+        result = uint64_frame.T
+        expected = DataFrame(uint64_frame.values.T)
+        expected.index = ["A", "B"]
+        tm.assert_frame_equal(result, expected)
+
+    def test_transpose_float(self, float_frame):
+        frame = float_frame
+        dft = frame.T
+        for idx, series in dft.items():
+            for col, value in series.items():
+                if np.isnan(value):
+                    assert np.isnan(frame[col][idx])
+                else:
+                    assert value == frame[col][idx]
+
+        # mixed type
+        index, data = tm.getMixedTypeDict()
+        mixed = DataFrame(data, index=index)
+
+        mixed_T = mixed.T
+        for col, s in mixed_T.items():
+            assert s.dtype == np.object_
+
+    @td.skip_array_manager_invalid_test
+    def test_transpose_get_view(self, float_frame, using_copy_on_write):
+        dft = float_frame.T
+        dft.iloc[:, 5:10] = 5
+
+        if using_copy_on_write:
+            assert (float_frame.values[5:10] != 5).all()
+        else:
+            assert (float_frame.values[5:10] == 5).all()
+
+    @td.skip_array_manager_invalid_test
+    def test_transpose_get_view_dt64tzget_view(self, using_copy_on_write):
+        dti = date_range("2016-01-01", periods=6, tz="US/Pacific")
+        arr = dti._data.reshape(3, 2)
+        df = DataFrame(arr)
+        assert df._mgr.nblocks == 1
+
+        result = df.T
+        assert result._mgr.nblocks == 1
+
+        rtrip = result._mgr.blocks[0].values
+        if using_copy_on_write:
+            assert np.shares_memory(df._mgr.blocks[0].values._ndarray, rtrip._ndarray)
+        else:
+            assert np.shares_memory(arr._ndarray, rtrip._ndarray)
+
+    def test_transpose_not_inferring_dt(self):
+        # GH#51546
+        df = DataFrame(
+            {
+                "a": [Timestamp("2019-12-31"), Timestamp("2019-12-31")],
+            },
+            dtype=object,
+        )
+        result = df.T
+        expected = DataFrame(
+            [[Timestamp("2019-12-31"), Timestamp("2019-12-31")]],
+            columns=[0, 1],
+            index=["a"],
+            dtype=object,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_transpose_not_inferring_dt_mixed_blocks(self):
+        # GH#51546
+        df = DataFrame(
+            {
+                "a": Series(
+                    [Timestamp("2019-12-31"), Timestamp("2019-12-31")], dtype=object
+                ),
+                "b": [Timestamp("2019-12-31"), Timestamp("2019-12-31")],
+            }
+        )
+        result = df.T
+        expected = DataFrame(
+            [
+                [Timestamp("2019-12-31"), Timestamp("2019-12-31")],
+                [Timestamp("2019-12-31"), Timestamp("2019-12-31")],
+            ],
+            columns=[0, 1],
+            index=["a", "b"],
+            dtype=object,
+        )
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_truncate.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_truncate.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c4b04076c8d5f5f7a2c79298d31dc7e2c831622
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_truncate.py
@@ -0,0 +1,154 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameTruncate:
+    def test_truncate(self, datetime_frame, frame_or_series):
+        ts = datetime_frame[::3]
+        ts = tm.get_obj(ts, frame_or_series)
+
+        start, end = datetime_frame.index[3], datetime_frame.index[6]
+
+        start_missing = datetime_frame.index[2]
+        end_missing = datetime_frame.index[7]
+
+        # neither specified
+        truncated = ts.truncate()
+        tm.assert_equal(truncated, ts)
+
+        # both specified
+        expected = ts[1:3]
+
+        truncated = ts.truncate(start, end)
+        tm.assert_equal(truncated, expected)
+
+        truncated = ts.truncate(start_missing, end_missing)
+        tm.assert_equal(truncated, expected)
+
+        # start specified
+        expected = ts[1:]
+
+        truncated = ts.truncate(before=start)
+        tm.assert_equal(truncated, expected)
+
+        truncated = ts.truncate(before=start_missing)
+        tm.assert_equal(truncated, expected)
+
+        # end specified
+        expected = ts[:3]
+
+        truncated = ts.truncate(after=end)
+        tm.assert_equal(truncated, expected)
+
+        truncated = ts.truncate(after=end_missing)
+        tm.assert_equal(truncated, expected)
+
+        # corner case, empty series/frame returned
+        truncated = ts.truncate(after=ts.index[0] - ts.index.freq)
+        assert len(truncated) == 0
+
+        truncated = ts.truncate(before=ts.index[-1] + ts.index.freq)
+        assert len(truncated) == 0
+
+        msg = "Truncate: 2000-01-06 00:00:00 must be after 2000-02-04 00:00:00"
+        with pytest.raises(ValueError, match=msg):
+            ts.truncate(
+                before=ts.index[-1] - ts.index.freq, after=ts.index[0] + ts.index.freq
+            )
+
+    def test_truncate_nonsortedindex(self, frame_or_series):
+        # GH#17935
+
+        obj = DataFrame({"A": ["a", "b", "c", "d", "e"]}, index=[5, 3, 2, 9, 0])
+        obj = tm.get_obj(obj, frame_or_series)
+
+        msg = "truncate requires a sorted index"
+        with pytest.raises(ValueError, match=msg):
+            obj.truncate(before=3, after=9)
+
+    def test_sort_values_nonsortedindex(self):
+        rng = date_range("2011-01-01", "2012-01-01", freq="W")
+        ts = DataFrame(
+            {
+                "A": np.random.default_rng(2).standard_normal(len(rng)),
+                "B": np.random.default_rng(2).standard_normal(len(rng)),
+            },
+            index=rng,
+        )
+
+        decreasing = ts.sort_values("A", ascending=False)
+
+        msg = "truncate requires a sorted index"
+        with pytest.raises(ValueError, match=msg):
+            decreasing.truncate(before="2011-11", after="2011-12")
+
+    def test_truncate_nonsortedindex_axis1(self):
+        # GH#17935
+
+        df = DataFrame(
+            {
+                3: np.random.default_rng(2).standard_normal(5),
+                20: np.random.default_rng(2).standard_normal(5),
+                2: np.random.default_rng(2).standard_normal(5),
+                0: np.random.default_rng(2).standard_normal(5),
+            },
+            columns=[3, 20, 2, 0],
+        )
+        msg = "truncate requires a sorted index"
+        with pytest.raises(ValueError, match=msg):
+            df.truncate(before=2, after=20, axis=1)
+
+    @pytest.mark.parametrize(
+        "before, after, indices",
+        [(1, 2, [2, 1]), (None, 2, [2, 1, 0]), (1, None, [3, 2, 1])],
+    )
+    @pytest.mark.parametrize("dtyp", [*tm.ALL_REAL_NUMPY_DTYPES, "datetime64[ns]"])
+    def test_truncate_decreasing_index(
+        self, before, after, indices, dtyp, frame_or_series
+    ):
+        # https://github.com/pandas-dev/pandas/issues/33756
+        idx = Index([3, 2, 1, 0], dtype=dtyp)
+        if isinstance(idx, DatetimeIndex):
+            before = pd.Timestamp(before) if before is not None else None
+            after = pd.Timestamp(after) if after is not None else None
+            indices = [pd.Timestamp(i) for i in indices]
+        values = frame_or_series(range(len(idx)), index=idx)
+        result = values.truncate(before=before, after=after)
+        expected = values.loc[indices]
+        tm.assert_equal(result, expected)
+
+    def test_truncate_multiindex(self, frame_or_series):
+        # GH 34564
+        mi = pd.MultiIndex.from_product([[1, 2, 3, 4], ["A", "B"]], names=["L1", "L2"])
+        s1 = DataFrame(range(mi.shape[0]), index=mi, columns=["col"])
+        s1 = tm.get_obj(s1, frame_or_series)
+
+        result = s1.truncate(before=2, after=3)
+
+        df = DataFrame.from_dict(
+            {"L1": [2, 2, 3, 3], "L2": ["A", "B", "A", "B"], "col": [2, 3, 4, 5]}
+        )
+        expected = df.set_index(["L1", "L2"])
+        expected = tm.get_obj(expected, frame_or_series)
+
+        tm.assert_equal(result, expected)
+
+    def test_truncate_index_only_one_unique_value(self, frame_or_series):
+        # GH 42365
+        obj = Series(0, index=date_range("2021-06-30", "2021-06-30")).repeat(5)
+        if frame_or_series is DataFrame:
+            obj = obj.to_frame(name="a")
+
+        truncated = obj.truncate("2021-06-28", "2021-07-01")
+
+        tm.assert_equal(truncated, obj)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_tz_convert.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_tz_convert.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a484abaab54cbd104acbaf4bb3273f4e41ff55a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_tz_convert.py
@@ -0,0 +1,131 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestTZConvert:
+    def test_tz_convert(self, frame_or_series):
+        rng = date_range("1/1/2011", periods=200, freq="D", tz="US/Eastern")
+
+        obj = DataFrame({"a": 1}, index=rng)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        result = obj.tz_convert("Europe/Berlin")
+        expected = DataFrame({"a": 1}, rng.tz_convert("Europe/Berlin"))
+        expected = tm.get_obj(expected, frame_or_series)
+
+        assert result.index.tz.zone == "Europe/Berlin"
+        tm.assert_equal(result, expected)
+
+    def test_tz_convert_axis1(self):
+        rng = date_range("1/1/2011", periods=200, freq="D", tz="US/Eastern")
+
+        obj = DataFrame({"a": 1}, index=rng)
+
+        obj = obj.T
+        result = obj.tz_convert("Europe/Berlin", axis=1)
+        assert result.columns.tz.zone == "Europe/Berlin"
+
+        expected = DataFrame({"a": 1}, rng.tz_convert("Europe/Berlin"))
+
+        tm.assert_equal(result, expected.T)
+
+    def test_tz_convert_naive(self, frame_or_series):
+        # can't convert tz-naive
+        rng = date_range("1/1/2011", periods=200, freq="D")
+        ts = Series(1, index=rng)
+        ts = frame_or_series(ts)
+
+        with pytest.raises(TypeError, match="Cannot convert tz-naive"):
+            ts.tz_convert("US/Eastern")
+
+    @pytest.mark.parametrize("fn", ["tz_localize", "tz_convert"])
+    def test_tz_convert_and_localize(self, fn):
+        l0 = date_range("20140701", periods=5, freq="D")
+        l1 = date_range("20140701", periods=5, freq="D")
+
+        int_idx = Index(range(5))
+
+        if fn == "tz_convert":
+            l0 = l0.tz_localize("UTC")
+            l1 = l1.tz_localize("UTC")
+
+        for idx in [l0, l1]:
+            l0_expected = getattr(idx, fn)("US/Pacific")
+            l1_expected = getattr(idx, fn)("US/Pacific")
+
+            df1 = DataFrame(np.ones(5), index=l0)
+            df1 = getattr(df1, fn)("US/Pacific")
+            tm.assert_index_equal(df1.index, l0_expected)
+
+            # MultiIndex
+            # GH7846
+            df2 = DataFrame(np.ones(5), MultiIndex.from_arrays([l0, l1]))
+
+            # freq is not preserved in MultiIndex construction
+            l1_expected = l1_expected._with_freq(None)
+            l0_expected = l0_expected._with_freq(None)
+            l1 = l1._with_freq(None)
+            l0 = l0._with_freq(None)
+
+            df3 = getattr(df2, fn)("US/Pacific", level=0)
+            assert not df3.index.levels[0].equals(l0)
+            tm.assert_index_equal(df3.index.levels[0], l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1)
+            assert not df3.index.levels[1].equals(l1_expected)
+
+            df3 = getattr(df2, fn)("US/Pacific", level=1)
+            tm.assert_index_equal(df3.index.levels[0], l0)
+            assert not df3.index.levels[0].equals(l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1_expected)
+            assert not df3.index.levels[1].equals(l1)
+
+            df4 = DataFrame(np.ones(5), MultiIndex.from_arrays([int_idx, l0]))
+
+            # TODO: untested
+            getattr(df4, fn)("US/Pacific", level=1)
+
+            tm.assert_index_equal(df3.index.levels[0], l0)
+            assert not df3.index.levels[0].equals(l0_expected)
+            tm.assert_index_equal(df3.index.levels[1], l1_expected)
+            assert not df3.index.levels[1].equals(l1)
+
+        # Bad Inputs
+
+        # Not DatetimeIndex / PeriodIndex
+        with pytest.raises(TypeError, match="DatetimeIndex"):
+            df = DataFrame(index=int_idx)
+            getattr(df, fn)("US/Pacific")
+
+        # Not DatetimeIndex / PeriodIndex
+        with pytest.raises(TypeError, match="DatetimeIndex"):
+            df = DataFrame(np.ones(5), MultiIndex.from_arrays([int_idx, l0]))
+            getattr(df, fn)("US/Pacific", level=0)
+
+        # Invalid level
+        with pytest.raises(ValueError, match="not valid"):
+            df = DataFrame(index=l0)
+            getattr(df, fn)("US/Pacific", level=1)
+
+    @pytest.mark.parametrize("copy", [True, False])
+    def test_tz_convert_copy_inplace_mutate(self, copy, frame_or_series):
+        # GH#6326
+        obj = frame_or_series(
+            np.arange(0, 5),
+            index=date_range("20131027", periods=5, freq="1H", tz="Europe/Berlin"),
+        )
+        orig = obj.copy()
+        result = obj.tz_convert("UTC", copy=copy)
+        expected = frame_or_series(np.arange(0, 5), index=obj.index.tz_convert("UTC"))
+        tm.assert_equal(result, expected)
+        tm.assert_equal(obj, orig)
+        assert result.index is not obj.index
+        assert result is not obj
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_tz_localize.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_tz_localize.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed2b0b247e62c55b4b2c5fc84fb1ee0cb7f564ab
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_tz_localize.py
@@ -0,0 +1,68 @@
+from datetime import timezone
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestTZLocalize:
+    # See also:
+    # test_tz_convert_and_localize in test_tz_convert
+
+    def test_tz_localize(self, frame_or_series):
+        rng = date_range("1/1/2011", periods=100, freq="H")
+
+        obj = DataFrame({"a": 1}, index=rng)
+        obj = tm.get_obj(obj, frame_or_series)
+
+        result = obj.tz_localize("utc")
+        expected = DataFrame({"a": 1}, rng.tz_localize("UTC"))
+        expected = tm.get_obj(expected, frame_or_series)
+
+        assert result.index.tz is timezone.utc
+        tm.assert_equal(result, expected)
+
+    def test_tz_localize_axis1(self):
+        rng = date_range("1/1/2011", periods=100, freq="H")
+
+        df = DataFrame({"a": 1}, index=rng)
+
+        df = df.T
+        result = df.tz_localize("utc", axis=1)
+        assert result.columns.tz is timezone.utc
+
+        expected = DataFrame({"a": 1}, rng.tz_localize("UTC"))
+
+        tm.assert_frame_equal(result, expected.T)
+
+    def test_tz_localize_naive(self, frame_or_series):
+        # Can't localize if already tz-aware
+        rng = date_range("1/1/2011", periods=100, freq="H", tz="utc")
+        ts = Series(1, index=rng)
+        ts = frame_or_series(ts)
+
+        with pytest.raises(TypeError, match="Already tz-aware"):
+            ts.tz_localize("US/Eastern")
+
+    @pytest.mark.parametrize("copy", [True, False])
+    def test_tz_localize_copy_inplace_mutate(self, copy, frame_or_series):
+        # GH#6326
+        obj = frame_or_series(
+            np.arange(0, 5), index=date_range("20131027", periods=5, freq="1H", tz=None)
+        )
+        orig = obj.copy()
+        result = obj.tz_localize("UTC", copy=copy)
+        expected = frame_or_series(
+            np.arange(0, 5),
+            index=date_range("20131027", periods=5, freq="1H", tz="UTC"),
+        )
+        tm.assert_equal(result, expected)
+        tm.assert_equal(obj, orig)
+        assert result.index is not obj.index
+        assert result is not obj
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_update.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_update.py
new file mode 100644
index 0000000000000000000000000000000000000000..5738a25f26fcbb06dd555c13de8ee6487fad5476
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_update.py
@@ -0,0 +1,179 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameUpdate:
+    def test_update_nan(self):
+        # #15593 #15617
+        # test 1
+        df1 = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
+        df2 = DataFrame({"A": [None, 2, 3]})
+        expected = df1.copy()
+        df1.update(df2, overwrite=False)
+
+        tm.assert_frame_equal(df1, expected)
+
+        # test 2
+        df1 = DataFrame({"A": [1.0, None, 3], "B": date_range("2000", periods=3)})
+        df2 = DataFrame({"A": [None, 2, 3]})
+        expected = DataFrame({"A": [1.0, 2, 3], "B": date_range("2000", periods=3)})
+        df1.update(df2, overwrite=False)
+
+        tm.assert_frame_equal(df1, expected)
+
+    def test_update(self):
+        df = DataFrame(
+            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
+
+        df.update(other)
+
+        expected = DataFrame(
+            [[1.5, np.nan, 3], [3.6, 2, 3], [1.5, np.nan, 3], [1.5, np.nan, 7.0]]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_dtypes(self):
+        # gh 3016
+        df = DataFrame(
+            [[1.0, 2.0, False, True], [4.0, 5.0, True, False]],
+            columns=["A", "B", "bool1", "bool2"],
+        )
+
+        other = DataFrame([[45, 45]], index=[0], columns=["A", "B"])
+        df.update(other)
+
+        expected = DataFrame(
+            [[45.0, 45.0, False, True], [4.0, 5.0, True, False]],
+            columns=["A", "B", "bool1", "bool2"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_nooverwrite(self):
+        df = DataFrame(
+            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
+
+        df.update(other, overwrite=False)
+
+        expected = DataFrame(
+            [[1.5, np.nan, 3], [1.5, 2, 3], [1.5, np.nan, 3], [1.5, np.nan, 3.0]]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_filtered(self):
+        df = DataFrame(
+            [[1.5, np.nan, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[3.6, 2.0, np.nan], [np.nan, np.nan, 7]], index=[1, 3])
+
+        df.update(other, filter_func=lambda x: x > 2)
+
+        expected = DataFrame(
+            [[1.5, np.nan, 3], [1.5, np.nan, 3], [1.5, np.nan, 3], [1.5, np.nan, 7.0]]
+        )
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "bad_kwarg, exception, msg",
+        [
+            # errors must be 'ignore' or 'raise'
+            ({"errors": "something"}, ValueError, "The parameter errors must.*"),
+            ({"join": "inner"}, NotImplementedError, "Only left join is supported"),
+        ],
+    )
+    def test_update_raise_bad_parameter(self, bad_kwarg, exception, msg):
+        df = DataFrame([[1.5, 1, 3.0]])
+        with pytest.raises(exception, match=msg):
+            df.update(df, **bad_kwarg)
+
+    def test_update_raise_on_overlap(self):
+        df = DataFrame(
+            [[1.5, 1, 3.0], [1.5, np.nan, 3.0], [1.5, np.nan, 3], [1.5, np.nan, 3]]
+        )
+
+        other = DataFrame([[2.0, np.nan], [np.nan, 7]], index=[1, 3], columns=[1, 2])
+        with pytest.raises(ValueError, match="Data overlaps"):
+            df.update(other, errors="raise")
+
+    def test_update_from_non_df(self):
+        d = {"a": Series([1, 2, 3, 4]), "b": Series([5, 6, 7, 8])}
+        df = DataFrame(d)
+
+        d["a"] = Series([5, 6, 7, 8])
+        df.update(d)
+
+        expected = DataFrame(d)
+
+        tm.assert_frame_equal(df, expected)
+
+        d = {"a": [1, 2, 3, 4], "b": [5, 6, 7, 8]}
+        df = DataFrame(d)
+
+        d["a"] = [5, 6, 7, 8]
+        df.update(d)
+
+        expected = DataFrame(d)
+
+        tm.assert_frame_equal(df, expected)
+
+    def test_update_datetime_tz(self):
+        # GH 25807
+        result = DataFrame([pd.Timestamp("2019", tz="UTC")])
+        with tm.assert_produces_warning(None):
+            result.update(result)
+        expected = DataFrame([pd.Timestamp("2019", tz="UTC")])
+        tm.assert_frame_equal(result, expected)
+
+    def test_update_with_different_dtype(self, using_copy_on_write):
+        # GH#3217
+        df = DataFrame({"a": [1, 3], "b": [np.nan, 2]})
+        df["c"] = np.nan
+        if using_copy_on_write:
+            df.update({"c": Series(["foo"], index=[0])})
+        else:
+            with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+                df["c"].update(Series(["foo"], index=[0]))
+
+        expected = DataFrame({"a": [1, 3], "b": [np.nan, 2], "c": ["foo", np.nan]})
+        tm.assert_frame_equal(df, expected)
+
+    @td.skip_array_manager_invalid_test
+    def test_update_modify_view(self, using_copy_on_write):
+        # GH#47188
+        df = DataFrame({"A": ["1", np.nan], "B": ["100", np.nan]})
+        df2 = DataFrame({"A": ["a", "x"], "B": ["100", "200"]})
+        df2_orig = df2.copy()
+        result_view = df2[:]
+        df2.update(df)
+        expected = DataFrame({"A": ["1", "x"], "B": ["100", "200"]})
+        tm.assert_frame_equal(df2, expected)
+        if using_copy_on_write:
+            tm.assert_frame_equal(result_view, df2_orig)
+        else:
+            tm.assert_frame_equal(result_view, expected)
+
+    def test_update_dt_column_with_NaT_create_column(self):
+        # GH#16713
+        df = DataFrame({"A": [1, None], "B": [pd.NaT, pd.to_datetime("2016-01-01")]})
+        df2 = DataFrame({"A": [2, 3]})
+        df.update(df2, overwrite=False)
+        expected = DataFrame(
+            {"A": [1.0, 3.0], "B": [pd.NaT, pd.to_datetime("2016-01-01")]}
+        )
+        tm.assert_frame_equal(df, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_value_counts.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_value_counts.py
new file mode 100644
index 0000000000000000000000000000000000000000..c05a92936047829255e117d65e2b94b809ef874e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_value_counts.py
@@ -0,0 +1,191 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_data_frame_value_counts_unsorted():
+    df = pd.DataFrame(
+        {"num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
+        index=["falcon", "dog", "cat", "ant"],
+    )
+
+    result = df.value_counts(sort=False)
+    expected = pd.Series(
+        data=[1, 2, 1],
+        index=pd.MultiIndex.from_arrays(
+            [(2, 4, 6), (2, 0, 0)], names=["num_legs", "num_wings"]
+        ),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_ascending():
+    df = pd.DataFrame(
+        {"num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
+        index=["falcon", "dog", "cat", "ant"],
+    )
+
+    result = df.value_counts(ascending=True)
+    expected = pd.Series(
+        data=[1, 1, 2],
+        index=pd.MultiIndex.from_arrays(
+            [(2, 6, 4), (2, 0, 0)], names=["num_legs", "num_wings"]
+        ),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_default():
+    df = pd.DataFrame(
+        {"num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
+        index=["falcon", "dog", "cat", "ant"],
+    )
+
+    result = df.value_counts()
+    expected = pd.Series(
+        data=[2, 1, 1],
+        index=pd.MultiIndex.from_arrays(
+            [(4, 2, 6), (0, 2, 0)], names=["num_legs", "num_wings"]
+        ),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_normalize():
+    df = pd.DataFrame(
+        {"num_legs": [2, 4, 4, 6], "num_wings": [2, 0, 0, 0]},
+        index=["falcon", "dog", "cat", "ant"],
+    )
+
+    result = df.value_counts(normalize=True)
+    expected = pd.Series(
+        data=[0.5, 0.25, 0.25],
+        index=pd.MultiIndex.from_arrays(
+            [(4, 2, 6), (0, 2, 0)], names=["num_legs", "num_wings"]
+        ),
+        name="proportion",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_single_col_default():
+    df = pd.DataFrame({"num_legs": [2, 4, 4, 6]})
+
+    result = df.value_counts()
+    expected = pd.Series(
+        data=[2, 1, 1],
+        index=pd.MultiIndex.from_arrays([[4, 2, 6]], names=["num_legs"]),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_empty():
+    df_no_cols = pd.DataFrame()
+
+    result = df_no_cols.value_counts()
+    expected = pd.Series(
+        [], dtype=np.int64, name="count", index=np.array([], dtype=np.intp)
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_empty_normalize():
+    df_no_cols = pd.DataFrame()
+
+    result = df_no_cols.value_counts(normalize=True)
+    expected = pd.Series(
+        [], dtype=np.float64, name="proportion", index=np.array([], dtype=np.intp)
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_dropna_true(nulls_fixture):
+    # GH 41334
+    df = pd.DataFrame(
+        {
+            "first_name": ["John", "Anne", "John", "Beth"],
+            "middle_name": ["Smith", nulls_fixture, nulls_fixture, "Louise"],
+        },
+    )
+    result = df.value_counts()
+    expected = pd.Series(
+        data=[1, 1],
+        index=pd.MultiIndex.from_arrays(
+            [("Beth", "John"), ("Louise", "Smith")], names=["first_name", "middle_name"]
+        ),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_data_frame_value_counts_dropna_false(nulls_fixture):
+    # GH 41334
+    df = pd.DataFrame(
+        {
+            "first_name": ["John", "Anne", "John", "Beth"],
+            "middle_name": ["Smith", nulls_fixture, nulls_fixture, "Louise"],
+        },
+    )
+
+    result = df.value_counts(dropna=False)
+    expected = pd.Series(
+        data=[1, 1, 1, 1],
+        index=pd.MultiIndex(
+            levels=[
+                pd.Index(["Anne", "Beth", "John"]),
+                pd.Index(["Louise", "Smith", nulls_fixture]),
+            ],
+            codes=[[0, 1, 2, 2], [2, 0, 1, 2]],
+            names=["first_name", "middle_name"],
+        ),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("columns", (["first_name", "middle_name"], [0, 1]))
+def test_data_frame_value_counts_subset(nulls_fixture, columns):
+    # GH 50829
+    df = pd.DataFrame(
+        {
+            columns[0]: ["John", "Anne", "John", "Beth"],
+            columns[1]: ["Smith", nulls_fixture, nulls_fixture, "Louise"],
+        },
+    )
+    result = df.value_counts(columns[0])
+    expected = pd.Series(
+        data=[2, 1, 1],
+        index=pd.Index(["John", "Anne", "Beth"], name=columns[0]),
+        name="count",
+    )
+
+    tm.assert_series_equal(result, expected)
+
+
+def test_value_counts_categorical_future_warning():
+    # GH#54775
+    df = pd.DataFrame({"a": [1, 2, 3]}, dtype="category")
+    result = df.value_counts()
+    expected = pd.Series(
+        1,
+        index=pd.MultiIndex.from_arrays(
+            [pd.Index([1, 2, 3], name="a", dtype="category")]
+        ),
+        name="count",
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_values.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_values.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbca4ee1b88b1b756ea27140d2944d349049c37c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/frame/methods/test_values.py
@@ -0,0 +1,280 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    DataFrame,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameValues:
+    @td.skip_array_manager_invalid_test
+    def test_values(self, float_frame, using_copy_on_write):
+        if using_copy_on_write:
+            with pytest.raises(ValueError, match="read-only"):
+                float_frame.values[:, 0] = 5.0
+            assert (float_frame.values[:, 0] != 5).all()
+        else:
+            float_frame.values[:, 0] = 5.0
+            assert (float_frame.values[:, 0] == 5).all()
+
+    def test_more_values(self, float_string_frame):
+        values = float_string_frame.values
+        assert values.shape[1] == len(float_string_frame.columns)
+
+    def test_values_mixed_dtypes(self, float_frame, float_string_frame):
+        frame = float_frame
+        arr = frame.values
+
+        frame_cols = frame.columns
+        for i, row in enumerate(arr):
+            for j, value in enumerate(row):
+                col = frame_cols[j]
+                if np.isnan(value):
+                    assert np.isnan(frame[col].iloc[i])
+                else:
+                    assert value == frame[col].iloc[i]
+
+        # mixed type
+        arr = float_string_frame[["foo", "A"]].values
+        assert arr[0, 0] == "bar"
+
+        df = DataFrame({"complex": [1j, 2j, 3j], "real": [1, 2, 3]})
+        arr = df.values
+        assert arr[0, 0] == 1j
+
+    def test_values_duplicates(self):
+        df = DataFrame(
+            [[1, 2, "a", "b"], [1, 2, "a", "b"]], columns=["one", "one", "two", "two"]
+        )
+
+        result = df.values
+        expected = np.array([[1, 2, "a", "b"], [1, 2, "a", "b"]], dtype=object)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_values_with_duplicate_columns(self):
+        df = DataFrame([[1, 2.5], [3, 4.5]], index=[1, 2], columns=["x", "x"])
+        result = df.values
+        expected = np.array([[1, 2.5], [3, 4.5]])
+        assert (result == expected).all().all()
+
+    @pytest.mark.parametrize("constructor", [date_range, period_range])
+    def test_values_casts_datetimelike_to_object(self, constructor):
+        series = Series(constructor("2000-01-01", periods=10, freq="D"))
+
+        expected = series.astype("object")
+
+        df = DataFrame(
+            {"a": series, "b": np.random.default_rng(2).standard_normal(len(series))}
+        )
+
+        result = df.values.squeeze()
+        assert (result[:, 0] == expected.values).all()
+
+        df = DataFrame({"a": series, "b": ["foo"] * len(series)})
+
+        result = df.values.squeeze()
+        assert (result[:, 0] == expected.values).all()
+
+    def test_frame_values_with_tz(self):
+        tz = "US/Central"
+        df = DataFrame({"A": date_range("2000", periods=4, tz=tz)})
+        result = df.values
+        expected = np.array(
+            [
+                [Timestamp("2000-01-01", tz=tz)],
+                [Timestamp("2000-01-02", tz=tz)],
+                [Timestamp("2000-01-03", tz=tz)],
+                [Timestamp("2000-01-04", tz=tz)],
+            ]
+        )
+        tm.assert_numpy_array_equal(result, expected)
+
+        # two columns, homogeneous
+
+        df["B"] = df["A"]
+        result = df.values
+        expected = np.concatenate([expected, expected], axis=1)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # three columns, heterogeneous
+        est = "US/Eastern"
+        df["C"] = df["A"].dt.tz_convert(est)
+
+        new = np.array(
+            [
+                [Timestamp("2000-01-01T01:00:00", tz=est)],
+                [Timestamp("2000-01-02T01:00:00", tz=est)],
+                [Timestamp("2000-01-03T01:00:00", tz=est)],
+                [Timestamp("2000-01-04T01:00:00", tz=est)],
+            ]
+        )
+        expected = np.concatenate([expected, new], axis=1)
+        result = df.values
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_interleave_with_tzaware(self, timezone_frame):
+        # interleave with object
+        result = timezone_frame.assign(D="foo").values
+        expected = np.array(
+            [
+                [
+                    Timestamp("2013-01-01 00:00:00"),
+                    Timestamp("2013-01-02 00:00:00"),
+                    Timestamp("2013-01-03 00:00:00"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
+                ],
+                ["foo", "foo", "foo"],
+            ],
+            dtype=object,
+        ).T
+        tm.assert_numpy_array_equal(result, expected)
+
+        # interleave with only datetime64[ns]
+        result = timezone_frame.values
+        expected = np.array(
+            [
+                [
+                    Timestamp("2013-01-01 00:00:00"),
+                    Timestamp("2013-01-02 00:00:00"),
+                    Timestamp("2013-01-03 00:00:00"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
+                ],
+            ],
+            dtype=object,
+        ).T
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_values_interleave_non_unique_cols(self):
+        df = DataFrame(
+            [[Timestamp("20130101"), 3.5], [Timestamp("20130102"), 4.5]],
+            columns=["x", "x"],
+            index=[1, 2],
+        )
+
+        df_unique = df.copy()
+        df_unique.columns = ["x", "y"]
+        assert df_unique.values.shape == df.values.shape
+        tm.assert_numpy_array_equal(df_unique.values[0], df.values[0])
+        tm.assert_numpy_array_equal(df_unique.values[1], df.values[1])
+
+    def test_values_numeric_cols(self, float_frame):
+        float_frame["foo"] = "bar"
+
+        values = float_frame[["A", "B", "C", "D"]].values
+        assert values.dtype == np.float64
+
+    def test_values_lcd(self, mixed_float_frame, mixed_int_frame):
+        # mixed lcd
+        values = mixed_float_frame[["A", "B", "C", "D"]].values
+        assert values.dtype == np.float64
+
+        values = mixed_float_frame[["A", "B", "C"]].values
+        assert values.dtype == np.float32
+
+        values = mixed_float_frame[["C"]].values
+        assert values.dtype == np.float16
+
+        # GH#10364
+        # B uint64 forces float because there are other signed int types
+        values = mixed_int_frame[["A", "B", "C", "D"]].values
+        assert values.dtype == np.float64
+
+        values = mixed_int_frame[["A", "D"]].values
+        assert values.dtype == np.int64
+
+        # B uint64 forces float because there are other signed int types
+        values = mixed_int_frame[["A", "B", "C"]].values
+        assert values.dtype == np.float64
+
+        # as B and C are both unsigned, no forcing to float is needed
+        values = mixed_int_frame[["B", "C"]].values
+        assert values.dtype == np.uint64
+
+        values = mixed_int_frame[["A", "C"]].values
+        assert values.dtype == np.int32
+
+        values = mixed_int_frame[["C", "D"]].values
+        assert values.dtype == np.int64
+
+        values = mixed_int_frame[["A"]].values
+        assert values.dtype == np.int32
+
+        values = mixed_int_frame[["C"]].values
+        assert values.dtype == np.uint8
+
+
+class TestPrivateValues:
+    @td.skip_array_manager_invalid_test
+    def test_private_values_dt64tz(self, using_copy_on_write):
+        dta = date_range("2000", periods=4, tz="US/Central")._data.reshape(-1, 1)
+
+        df = DataFrame(dta, columns=["A"])
+        tm.assert_equal(df._values, dta)
+
+        if using_copy_on_write:
+            assert not np.shares_memory(df._values._ndarray, dta._ndarray)
+        else:
+            # we have a view
+            assert np.shares_memory(df._values._ndarray, dta._ndarray)
+
+        # TimedeltaArray
+        tda = dta - dta
+        df2 = df - df
+        tm.assert_equal(df2._values, tda)
+
+    @td.skip_array_manager_invalid_test
+    def test_private_values_dt64tz_multicol(self, using_copy_on_write):
+        dta = date_range("2000", periods=8, tz="US/Central")._data.reshape(-1, 2)
+
+        df = DataFrame(dta, columns=["A", "B"])
+        tm.assert_equal(df._values, dta)
+
+        if using_copy_on_write:
+            assert not np.shares_memory(df._values._ndarray, dta._ndarray)
+        else:
+            # we have a view
+            assert np.shares_memory(df._values._ndarray, dta._ndarray)
+
+        # TimedeltaArray
+        tda = dta - dta
+        df2 = df - df
+        tm.assert_equal(df2._values, tda)
+
+    def test_private_values_dt64_multiblock(self):
+        dta = date_range("2000", periods=8)._data
+
+        df = DataFrame({"A": dta[:4]}, copy=False)
+        df["B"] = dta[4:]
+
+        assert len(df._mgr.arrays) == 2
+
+        result = df._values
+        expected = dta.reshape(2, 4).T
+        tm.assert_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f96548cf62679a14d8a8d477a3e676a66ccff6ca
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_duplicate_labels.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_duplicate_labels.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..86e27f7bf78b45cb485a3769889ddd1d00d2f513
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_duplicate_labels.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_finalize.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_finalize.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..736254bbf97a4b0dd45598b52ff486de347a3dac
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_finalize.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_frame.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_frame.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd22841379850d629653ee8b8858fcb6500da5be
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_frame.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_generic.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_generic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2bd4af93cf63bfdda37ba88524cb42ce269c9ea
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_generic.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_label_or_level_utils.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_label_or_level_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b071f58436dd4e2a141bdad582eb315b7b10b25
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_label_or_level_utils.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_series.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_series.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80fa82e6efac5ab7dc93504bd8f3e9461a40f921
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_series.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_to_xarray.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_to_xarray.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f5f6680cbd1e4a915c22d28672ff26d0d340c03
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/generic/__pycache__/test_to_xarray.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77970f57d79833316cf5763c68c5d77936aaf06a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/conftest.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/conftest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36ea67f846373da39b874e6af2f6515a5e14eaf6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/conftest.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_base.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_base.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fee39656505d95cca83f06c4ff522cb8e6c8e44b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_base.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_datetime_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_datetime_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14d02eb35ec8d8e51dbf51b8bc861783fd476a0c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_datetime_index.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cca0ddf8e3e830000b928450a48cf0351acc07c362872b1fea31c9318bdd50c5
+size 112727
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_period_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_period_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f65262cf1469729a139c0b871a2711a555fa4802
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_period_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_resample_api.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_resample_api.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7edc3dcffd3907fd3a3bfa42b811325214087f52
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_resample_api.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_resampler_grouper.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_resampler_grouper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0f268b950fc1877709667485b5d27f66cd076aa
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_resampler_grouper.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_time_grouper.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_time_grouper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b399fea10ab7a5aebfebde2e1ef701a043875b86
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_time_grouper.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_timedelta.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_timedelta.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a22697022354a8143e17e9ac64b57369d9c239b0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/resample/__pycache__/test_timedelta.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee3b6f7fc28e6b2ae63f3e05c16ded515c81620e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_crosstab.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_crosstab.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..51d80892095b9b98c3b14245c10864f82687b16c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_crosstab.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_cut.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_cut.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4f7a0da7297d50f267b130c7eec8675031a2a91
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_cut.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_from_dummies.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_from_dummies.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a121926be9d9537c5640cba4b7eb399ea2ef0612
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_from_dummies.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_get_dummies.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_get_dummies.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7d3c28152eb01e22012f3a04734006db9167a57
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_get_dummies.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_melt.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_melt.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eef5a23102c592e8bc39cccff1c6df798b6c14b1
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_melt.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8925941f39d075ea4dfd7b7fe45a924fff251bde
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bcc1ee287d4a0f9cda0a0ef6f6f04ced98e67489c965b3ef4c8eba4f1cc998e
+size 109584
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot_multilevel.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot_multilevel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..344d319b4000d0f743382c261c980a9059c57767
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_pivot_multilevel.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_qcut.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_qcut.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72caac187fa5e8db93d980b676fdd432bda2a88b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_qcut.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_union_categoricals.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_union_categoricals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4d484e1d29e4e21c9f95da4a9019dd30171f7df
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_union_categoricals.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_util.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..34349df14ffa7a16886e483cb05ad45427ebd58b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/__pycache__/test_util.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d70ecb5f3c9ab4e3e399b379a3a6eb665a59f6ca
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/conftest.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/conftest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55a5978f2986db4c826d6ee809fc7533074e3637
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/conftest.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_append.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_append.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01fe97e44b8b5504ca96dd657bc119cd05d82386
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_append.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_append_common.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_append_common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..498d8ea12ad0917dd61c3e5619c0fd13588904ac
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_append_common.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_categorical.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_categorical.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46060061a640101727cbf19707b82e06767d5108
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_categorical.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_concat.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_concat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c36ad109b15ce3814772b1af228d84e177700b6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_concat.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_dataframe.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_dataframe.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..589b192f7b88f3235ff47034ccb29b2467cf098e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_dataframe.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_datetimes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_datetimes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05cd125076b654f33dbcb0f4b435d691a94a8fda
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_datetimes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_empty.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_empty.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e39c36655a1fb8cb9cf9b7d9f7d54c30f6374fb1
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_empty.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d29429a7cf7aee87acbe124b91aef4cced661a61
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_invalid.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_invalid.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3279ed1a9da72f416c919326b815ec4056c4bab
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_invalid.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_series.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_series.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60bf743eb119da2416923a7f5afdb382ad1b0728
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_series.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_sort.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_sort.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13ca5ba9b1f0881abb34caa54d4858ea04cd13dc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/__pycache__/test_sort.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/conftest.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..62b8c59ba8855b2ef4273a33b475b2e16b7b3d1b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/conftest.py
@@ -0,0 +1,7 @@
+import pytest
+
+
+@pytest.fixture(params=[True, False])
+def sort(request):
+    """Boolean sort keyword for concat and DataFrame.append."""
+    return request.param
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_append.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_append.py
new file mode 100644
index 0000000000000000000000000000000000000000..81ca227fb7afb9768909f3cca7907fdaf74c430a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_append.py
@@ -0,0 +1,389 @@
+import datetime as dt
+from itertools import combinations
+
+import dateutil
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+    concat,
+    isna,
+)
+import pandas._testing as tm
+
+
+class TestAppend:
+    def test_append(self, sort, float_frame):
+        mixed_frame = float_frame.copy()
+        mixed_frame["foo"] = "bar"
+
+        begin_index = float_frame.index[:5]
+        end_index = float_frame.index[5:]
+
+        begin_frame = float_frame.reindex(begin_index)
+        end_frame = float_frame.reindex(end_index)
+
+        appended = begin_frame._append(end_frame)
+        tm.assert_almost_equal(appended["A"], float_frame["A"])
+
+        del end_frame["A"]
+        partial_appended = begin_frame._append(end_frame, sort=sort)
+        assert "A" in partial_appended
+
+        partial_appended = end_frame._append(begin_frame, sort=sort)
+        assert "A" in partial_appended
+
+        # mixed type handling
+        appended = mixed_frame[:5]._append(mixed_frame[5:])
+        tm.assert_frame_equal(appended, mixed_frame)
+
+        # what to test here
+        mixed_appended = mixed_frame[:5]._append(float_frame[5:], sort=sort)
+        mixed_appended2 = float_frame[:5]._append(mixed_frame[5:], sort=sort)
+
+        # all equal except 'foo' column
+        tm.assert_frame_equal(
+            mixed_appended.reindex(columns=["A", "B", "C", "D"]),
+            mixed_appended2.reindex(columns=["A", "B", "C", "D"]),
+        )
+
+    def test_append_empty(self, float_frame):
+        empty = DataFrame()
+
+        appended = float_frame._append(empty)
+        tm.assert_frame_equal(float_frame, appended)
+        assert appended is not float_frame
+
+        appended = empty._append(float_frame)
+        tm.assert_frame_equal(float_frame, appended)
+        assert appended is not float_frame
+
+    def test_append_overlap_raises(self, float_frame):
+        msg = "Indexes have overlapping values"
+        with pytest.raises(ValueError, match=msg):
+            float_frame._append(float_frame, verify_integrity=True)
+
+    def test_append_new_columns(self):
+        # see gh-6129: new columns
+        df = DataFrame({"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}})
+        row = Series([5, 6, 7], index=["a", "b", "c"], name="z")
+        expected = DataFrame(
+            {
+                "a": {"x": 1, "y": 2, "z": 5},
+                "b": {"x": 3, "y": 4, "z": 6},
+                "c": {"z": 7},
+            }
+        )
+        result = df._append(row)
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_length0_frame(self, sort):
+        df = DataFrame(columns=["A", "B", "C"])
+        df3 = DataFrame(index=[0, 1], columns=["A", "B"])
+        df5 = df._append(df3, sort=sort)
+
+        expected = DataFrame(index=[0, 1], columns=["A", "B", "C"])
+        tm.assert_frame_equal(df5, expected)
+
+    def test_append_records(self):
+        arr1 = np.zeros((2,), dtype=("i4,f4,S10"))
+        arr1[:] = [(1, 2.0, "Hello"), (2, 3.0, "World")]
+
+        arr2 = np.zeros((3,), dtype=("i4,f4,S10"))
+        arr2[:] = [(3, 4.0, "foo"), (5, 6.0, "bar"), (7.0, 8.0, "baz")]
+
+        df1 = DataFrame(arr1)
+        df2 = DataFrame(arr2)
+
+        result = df1._append(df2, ignore_index=True)
+        expected = DataFrame(np.concatenate((arr1, arr2)))
+        tm.assert_frame_equal(result, expected)
+
+    # rewrite sort fixture, since we also want to test default of None
+    def test_append_sorts(self, sort):
+        df1 = DataFrame({"a": [1, 2], "b": [1, 2]}, columns=["b", "a"])
+        df2 = DataFrame({"a": [1, 2], "c": [3, 4]}, index=[2, 3])
+
+        result = df1._append(df2, sort=sort)
+
+        # for None / True
+        expected = DataFrame(
+            {"b": [1, 2, None, None], "a": [1, 2, 1, 2], "c": [None, None, 3, 4]},
+            columns=["a", "b", "c"],
+        )
+        if sort is False:
+            expected = expected[["b", "a", "c"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_different_columns(self, sort):
+        df = DataFrame(
+            {
+                "bools": np.random.default_rng(2).standard_normal(10) > 0,
+                "ints": np.random.default_rng(2).integers(0, 10, 10),
+                "floats": np.random.default_rng(2).standard_normal(10),
+                "strings": ["foo", "bar"] * 5,
+            }
+        )
+
+        a = df[:5].loc[:, ["bools", "ints", "floats"]]
+        b = df[5:].loc[:, ["strings", "ints", "floats"]]
+
+        appended = a._append(b, sort=sort)
+        assert isna(appended["strings"][0:4]).all()
+        assert isna(appended["bools"][5:]).all()
+
+    def test_append_many(self, sort, float_frame):
+        chunks = [
+            float_frame[:5],
+            float_frame[5:10],
+            float_frame[10:15],
+            float_frame[15:],
+        ]
+
+        result = chunks[0]._append(chunks[1:])
+        tm.assert_frame_equal(result, float_frame)
+
+        chunks[-1] = chunks[-1].copy()
+        chunks[-1]["foo"] = "bar"
+        result = chunks[0]._append(chunks[1:], sort=sort)
+        tm.assert_frame_equal(result.loc[:, float_frame.columns], float_frame)
+        assert (result["foo"][15:] == "bar").all()
+        assert result["foo"][:15].isna().all()
+
+    def test_append_preserve_index_name(self):
+        # #980
+        df1 = DataFrame(columns=["A", "B", "C"])
+        df1 = df1.set_index(["A"])
+        df2 = DataFrame(data=[[1, 4, 7], [2, 5, 8], [3, 6, 9]], columns=["A", "B", "C"])
+        df2 = df2.set_index(["A"])
+
+        msg = "The behavior of array concatenation with empty entries is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = df1._append(df2)
+        assert result.index.name == "A"
+
+    indexes_can_append = [
+        pd.RangeIndex(3),
+        Index([4, 5, 6]),
+        Index([4.5, 5.5, 6.5]),
+        Index(list("abc")),
+        pd.CategoricalIndex("A B C".split()),
+        pd.CategoricalIndex("D E F".split(), ordered=True),
+        pd.IntervalIndex.from_breaks([7, 8, 9, 10]),
+        pd.DatetimeIndex(
+            [
+                dt.datetime(2013, 1, 3, 0, 0),
+                dt.datetime(2013, 1, 3, 6, 10),
+                dt.datetime(2013, 1, 3, 7, 12),
+            ]
+        ),
+        pd.MultiIndex.from_arrays(["A B C".split(), "D E F".split()]),
+    ]
+
+    @pytest.mark.parametrize(
+        "index", indexes_can_append, ids=lambda x: type(x).__name__
+    )
+    def test_append_same_columns_type(self, index):
+        # GH18359
+
+        # df wider than ser
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=index)
+        ser_index = index[:2]
+        ser = Series([7, 8], index=ser_index, name=2)
+        result = df._append(ser)
+        expected = DataFrame(
+            [[1, 2, 3.0], [4, 5, 6], [7, 8, np.nan]], index=[0, 1, 2], columns=index
+        )
+        # integer dtype is preserved for columns present in ser.index
+        assert expected.dtypes.iloc[0].kind == "i"
+        assert expected.dtypes.iloc[1].kind == "i"
+
+        tm.assert_frame_equal(result, expected)
+
+        # ser wider than df
+        ser_index = index
+        index = index[:2]
+        df = DataFrame([[1, 2], [4, 5]], columns=index)
+        ser = Series([7, 8, 9], index=ser_index, name=2)
+        result = df._append(ser)
+        expected = DataFrame(
+            [[1, 2, np.nan], [4, 5, np.nan], [7, 8, 9]],
+            index=[0, 1, 2],
+            columns=ser_index,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "df_columns, series_index",
+        combinations(indexes_can_append, r=2),
+        ids=lambda x: type(x).__name__,
+    )
+    def test_append_different_columns_types(self, df_columns, series_index):
+        # GH18359
+        # See also test 'test_append_different_columns_types_raises' below
+        # for errors raised when appending
+
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=df_columns)
+        ser = Series([7, 8, 9], index=series_index, name=2)
+
+        result = df._append(ser)
+        idx_diff = ser.index.difference(df_columns)
+        combined_columns = Index(df_columns.tolist()).append(idx_diff)
+        expected = DataFrame(
+            [
+                [1.0, 2.0, 3.0, np.nan, np.nan, np.nan],
+                [4, 5, 6, np.nan, np.nan, np.nan],
+                [np.nan, np.nan, np.nan, 7, 8, 9],
+            ],
+            index=[0, 1, 2],
+            columns=combined_columns,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_dtype_coerce(self, sort):
+        # GH 4993
+        # appending with datetime will incorrectly convert datetime64
+
+        df1 = DataFrame(
+            index=[1, 2],
+            data=[dt.datetime(2013, 1, 1, 0, 0), dt.datetime(2013, 1, 2, 0, 0)],
+            columns=["start_time"],
+        )
+        df2 = DataFrame(
+            index=[4, 5],
+            data=[
+                [dt.datetime(2013, 1, 3, 0, 0), dt.datetime(2013, 1, 3, 6, 10)],
+                [dt.datetime(2013, 1, 4, 0, 0), dt.datetime(2013, 1, 4, 7, 10)],
+            ],
+            columns=["start_time", "end_time"],
+        )
+
+        expected = concat(
+            [
+                Series(
+                    [
+                        pd.NaT,
+                        pd.NaT,
+                        dt.datetime(2013, 1, 3, 6, 10),
+                        dt.datetime(2013, 1, 4, 7, 10),
+                    ],
+                    name="end_time",
+                ),
+                Series(
+                    [
+                        dt.datetime(2013, 1, 1, 0, 0),
+                        dt.datetime(2013, 1, 2, 0, 0),
+                        dt.datetime(2013, 1, 3, 0, 0),
+                        dt.datetime(2013, 1, 4, 0, 0),
+                    ],
+                    name="start_time",
+                ),
+            ],
+            axis=1,
+            sort=sort,
+        )
+        result = df1._append(df2, ignore_index=True, sort=sort)
+        if sort:
+            expected = expected[["end_time", "start_time"]]
+        else:
+            expected = expected[["start_time", "end_time"]]
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_missing_column_proper_upcast(self, sort):
+        df1 = DataFrame({"A": np.array([1, 2, 3, 4], dtype="i8")})
+        df2 = DataFrame({"B": np.array([True, False, True, False], dtype=bool)})
+
+        appended = df1._append(df2, ignore_index=True, sort=sort)
+        assert appended["A"].dtype == "f8"
+        assert appended["B"].dtype == "O"
+
+    def test_append_empty_frame_to_series_with_dateutil_tz(self):
+        # GH 23682
+        date = Timestamp("2018-10-24 07:30:00", tz=dateutil.tz.tzutc())
+        ser = Series({"a": 1.0, "b": 2.0, "date": date})
+        df = DataFrame(columns=["c", "d"])
+        result_a = df._append(ser, ignore_index=True)
+        expected = DataFrame(
+            [[np.nan, np.nan, 1.0, 2.0, date]], columns=["c", "d", "a", "b", "date"]
+        )
+        # These columns get cast to object after append
+        expected["c"] = expected["c"].astype(object)
+        expected["d"] = expected["d"].astype(object)
+        tm.assert_frame_equal(result_a, expected)
+
+        expected = DataFrame(
+            [[np.nan, np.nan, 1.0, 2.0, date]] * 2, columns=["c", "d", "a", "b", "date"]
+        )
+        expected["c"] = expected["c"].astype(object)
+        expected["d"] = expected["d"].astype(object)
+        result_b = result_a._append(ser, ignore_index=True)
+        tm.assert_frame_equal(result_b, expected)
+
+        result = df._append([ser, ser], ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_append_empty_tz_frame_with_datetime64ns(self, using_array_manager):
+        # https://github.com/pandas-dev/pandas/issues/35460
+        df = DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
+
+        # pd.NaT gets inferred as tz-naive, so append result is tz-naive
+        result = df._append({"a": pd.NaT}, ignore_index=True)
+        if using_array_manager:
+            expected = DataFrame({"a": [pd.NaT]}, dtype=object)
+        else:
+            expected = DataFrame({"a": [np.nan]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+        # also test with typed value to append
+        df = DataFrame(columns=["a"]).astype("datetime64[ns, UTC]")
+        other = Series({"a": pd.NaT}, dtype="datetime64[ns]")
+        result = df._append(other, ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+        # mismatched tz
+        other = Series({"a": pd.NaT}, dtype="datetime64[ns, US/Pacific]")
+        result = df._append(other, ignore_index=True)
+        expected = DataFrame({"a": [pd.NaT]}).astype(object)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype_str", ["datetime64[ns, UTC]", "datetime64[ns]", "Int64", "int64"]
+    )
+    @pytest.mark.parametrize("val", [1, "NaT"])
+    def test_append_empty_frame_with_timedelta64ns_nat(
+        self, dtype_str, val, using_array_manager
+    ):
+        # https://github.com/pandas-dev/pandas/issues/35460
+        df = DataFrame(columns=["a"]).astype(dtype_str)
+
+        other = DataFrame({"a": [np.timedelta64(val, "ns")]})
+        result = df._append(other, ignore_index=True)
+
+        expected = other.astype(object)
+        if isinstance(val, str) and dtype_str != "int64" and not using_array_manager:
+            # TODO: expected used to be `other.astype(object)` which is a more
+            #  reasonable result.  This was changed when tightening
+            #  assert_frame_equal's treatment of mismatched NAs to match the
+            #  existing behavior.
+            expected = DataFrame({"a": [np.nan]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype_str", ["datetime64[ns, UTC]", "datetime64[ns]", "Int64", "int64"]
+    )
+    @pytest.mark.parametrize("val", [1, "NaT"])
+    def test_append_frame_with_timedelta64ns_nat(self, dtype_str, val):
+        # https://github.com/pandas-dev/pandas/issues/35460
+        df = DataFrame({"a": pd.array([1], dtype=dtype_str)})
+
+        other = DataFrame({"a": [np.timedelta64(val, "ns")]})
+        result = df._append(other, ignore_index=True)
+
+        expected = DataFrame({"a": [df.iloc[0, 0], other.iloc[0, 0]]}, dtype=object)
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_append_common.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_append_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..df5ca2f27c15dbb6d1b23db2793fac800927e5c7
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_append_common.py
@@ -0,0 +1,751 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture(
+    params=list(
+        {
+            "bool": [True, False, True],
+            "int64": [1, 2, 3],
+            "float64": [1.1, np.nan, 3.3],
+            "category": Categorical(["X", "Y", "Z"]),
+            "object": ["a", "b", "c"],
+            "datetime64[ns]": [
+                pd.Timestamp("2011-01-01"),
+                pd.Timestamp("2011-01-02"),
+                pd.Timestamp("2011-01-03"),
+            ],
+            "datetime64[ns, US/Eastern]": [
+                pd.Timestamp("2011-01-01", tz="US/Eastern"),
+                pd.Timestamp("2011-01-02", tz="US/Eastern"),
+                pd.Timestamp("2011-01-03", tz="US/Eastern"),
+            ],
+            "timedelta64[ns]": [
+                pd.Timedelta("1 days"),
+                pd.Timedelta("2 days"),
+                pd.Timedelta("3 days"),
+            ],
+            "period[M]": [
+                pd.Period("2011-01", freq="M"),
+                pd.Period("2011-02", freq="M"),
+                pd.Period("2011-03", freq="M"),
+            ],
+        }.items()
+    )
+)
+def item(request):
+    key, data = request.param
+    return key, data
+
+
+@pytest.fixture
+def item2(item):
+    return item
+
+
+class TestConcatAppendCommon:
+    """
+    Test common dtype coercion rules between concat and append.
+    """
+
+    def test_dtypes(self, item, index_or_series):
+        # to confirm test case covers intended dtypes
+        typ, vals = item
+        obj = index_or_series(vals)
+        if isinstance(obj, Index):
+            assert obj.dtype == typ
+        elif isinstance(obj, Series):
+            if typ.startswith("period"):
+                assert obj.dtype == "Period[M]"
+            else:
+                assert obj.dtype == typ
+
+    def test_concatlike_same_dtypes(self, item):
+        # GH 13660
+        typ1, vals1 = item
+
+        vals2 = vals1
+        vals3 = vals1
+
+        if typ1 == "category":
+            exp_data = Categorical(list(vals1) + list(vals2))
+            exp_data3 = Categorical(list(vals1) + list(vals2) + list(vals3))
+        else:
+            exp_data = vals1 + vals2
+            exp_data3 = vals1 + vals2 + vals3
+
+        # ----- Index ----- #
+
+        # index.append
+        res = Index(vals1).append(Index(vals2))
+        exp = Index(exp_data)
+        tm.assert_index_equal(res, exp)
+
+        # 3 elements
+        res = Index(vals1).append([Index(vals2), Index(vals3)])
+        exp = Index(exp_data3)
+        tm.assert_index_equal(res, exp)
+
+        # index.append name mismatch
+        i1 = Index(vals1, name="x")
+        i2 = Index(vals2, name="y")
+        res = i1.append(i2)
+        exp = Index(exp_data)
+        tm.assert_index_equal(res, exp)
+
+        # index.append name match
+        i1 = Index(vals1, name="x")
+        i2 = Index(vals2, name="x")
+        res = i1.append(i2)
+        exp = Index(exp_data, name="x")
+        tm.assert_index_equal(res, exp)
+
+        # cannot append non-index
+        with pytest.raises(TypeError, match="all inputs must be Index"):
+            Index(vals1).append(vals2)
+
+        with pytest.raises(TypeError, match="all inputs must be Index"):
+            Index(vals1).append([Index(vals2), vals3])
+
+        # ----- Series ----- #
+
+        # series.append
+        res = Series(vals1)._append(Series(vals2), ignore_index=True)
+        exp = Series(exp_data)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # concat
+        res = pd.concat([Series(vals1), Series(vals2)], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # 3 elements
+        res = Series(vals1)._append([Series(vals2), Series(vals3)], ignore_index=True)
+        exp = Series(exp_data3)
+        tm.assert_series_equal(res, exp)
+
+        res = pd.concat(
+            [Series(vals1), Series(vals2), Series(vals3)],
+            ignore_index=True,
+        )
+        tm.assert_series_equal(res, exp)
+
+        # name mismatch
+        s1 = Series(vals1, name="x")
+        s2 = Series(vals2, name="y")
+        res = s1._append(s2, ignore_index=True)
+        exp = Series(exp_data)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        res = pd.concat([s1, s2], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # name match
+        s1 = Series(vals1, name="x")
+        s2 = Series(vals2, name="x")
+        res = s1._append(s2, ignore_index=True)
+        exp = Series(exp_data, name="x")
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        res = pd.concat([s1, s2], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # cannot append non-index
+        msg = (
+            r"cannot concatenate object of type '.+'; "
+            "only Series and DataFrame objs are valid"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Series(vals1)._append(vals2)
+
+        with pytest.raises(TypeError, match=msg):
+            Series(vals1)._append([Series(vals2), vals3])
+
+        with pytest.raises(TypeError, match=msg):
+            pd.concat([Series(vals1), vals2])
+
+        with pytest.raises(TypeError, match=msg):
+            pd.concat([Series(vals1), Series(vals2), vals3])
+
+    def test_concatlike_dtypes_coercion(self, item, item2, request):
+        # GH 13660
+        typ1, vals1 = item
+        typ2, vals2 = item2
+
+        vals3 = vals2
+
+        # basically infer
+        exp_index_dtype = None
+        exp_series_dtype = None
+
+        if typ1 == typ2:
+            pytest.skip("same dtype is tested in test_concatlike_same_dtypes")
+        elif typ1 == "category" or typ2 == "category":
+            pytest.skip("categorical type tested elsewhere")
+
+        # specify expected dtype
+        if typ1 == "bool" and typ2 in ("int64", "float64"):
+            # series coerces to numeric based on numpy rule
+            # index doesn't because bool is object dtype
+            exp_series_dtype = typ2
+            mark = pytest.mark.xfail(reason="GH#39187 casting to object")
+            request.node.add_marker(mark)
+        elif typ2 == "bool" and typ1 in ("int64", "float64"):
+            exp_series_dtype = typ1
+            mark = pytest.mark.xfail(reason="GH#39187 casting to object")
+            request.node.add_marker(mark)
+        elif typ1 in {"datetime64[ns, US/Eastern]", "timedelta64[ns]"} or typ2 in {
+            "datetime64[ns, US/Eastern]",
+            "timedelta64[ns]",
+        }:
+            exp_index_dtype = object
+            exp_series_dtype = object
+
+        exp_data = vals1 + vals2
+        exp_data3 = vals1 + vals2 + vals3
+
+        # ----- Index ----- #
+
+        # index.append
+        # GH#39817
+        res = Index(vals1).append(Index(vals2))
+        exp = Index(exp_data, dtype=exp_index_dtype)
+        tm.assert_index_equal(res, exp)
+
+        # 3 elements
+        res = Index(vals1).append([Index(vals2), Index(vals3)])
+        exp = Index(exp_data3, dtype=exp_index_dtype)
+        tm.assert_index_equal(res, exp)
+
+        # ----- Series ----- #
+
+        # series._append
+        # GH#39817
+        res = Series(vals1)._append(Series(vals2), ignore_index=True)
+        exp = Series(exp_data, dtype=exp_series_dtype)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # concat
+        # GH#39817
+        res = pd.concat([Series(vals1), Series(vals2)], ignore_index=True)
+        tm.assert_series_equal(res, exp, check_index_type=True)
+
+        # 3 elements
+        # GH#39817
+        res = Series(vals1)._append([Series(vals2), Series(vals3)], ignore_index=True)
+        exp = Series(exp_data3, dtype=exp_series_dtype)
+        tm.assert_series_equal(res, exp)
+
+        # GH#39817
+        res = pd.concat(
+            [Series(vals1), Series(vals2), Series(vals3)],
+            ignore_index=True,
+        )
+        tm.assert_series_equal(res, exp)
+
+    def test_concatlike_common_coerce_to_pandas_object(self):
+        # GH 13626
+        # result must be Timestamp/Timedelta, not datetime.datetime/timedelta
+        dti = pd.DatetimeIndex(["2011-01-01", "2011-01-02"])
+        tdi = pd.TimedeltaIndex(["1 days", "2 days"])
+
+        exp = Index(
+            [
+                pd.Timestamp("2011-01-01"),
+                pd.Timestamp("2011-01-02"),
+                pd.Timedelta("1 days"),
+                pd.Timedelta("2 days"),
+            ]
+        )
+
+        res = dti.append(tdi)
+        tm.assert_index_equal(res, exp)
+        assert isinstance(res[0], pd.Timestamp)
+        assert isinstance(res[-1], pd.Timedelta)
+
+        dts = Series(dti)
+        tds = Series(tdi)
+        res = dts._append(tds)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+        assert isinstance(res.iloc[0], pd.Timestamp)
+        assert isinstance(res.iloc[-1], pd.Timedelta)
+
+        res = pd.concat([dts, tds])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+        assert isinstance(res.iloc[0], pd.Timestamp)
+        assert isinstance(res.iloc[-1], pd.Timedelta)
+
+    def test_concatlike_datetimetz(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH 7795
+        dti1 = pd.DatetimeIndex(["2011-01-01", "2011-01-02"], tz=tz)
+        dti2 = pd.DatetimeIndex(["2012-01-01", "2012-01-02"], tz=tz)
+
+        exp = pd.DatetimeIndex(
+            ["2011-01-01", "2011-01-02", "2012-01-01", "2012-01-02"], tz=tz
+        )
+
+        res = dti1.append(dti2)
+        tm.assert_index_equal(res, exp)
+
+        dts1 = Series(dti1)
+        dts2 = Series(dti2)
+        res = dts1._append(dts2)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([dts1, dts2])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+    @pytest.mark.parametrize("tz", ["UTC", "US/Eastern", "Asia/Tokyo", "EST5EDT"])
+    def test_concatlike_datetimetz_short(self, tz):
+        # GH#7795
+        ix1 = pd.date_range(start="2014-07-15", end="2014-07-17", freq="D", tz=tz)
+        ix2 = pd.DatetimeIndex(["2014-07-11", "2014-07-21"], tz=tz)
+        df1 = DataFrame(0, index=ix1, columns=["A", "B"])
+        df2 = DataFrame(0, index=ix2, columns=["A", "B"])
+
+        exp_idx = pd.DatetimeIndex(
+            ["2014-07-15", "2014-07-16", "2014-07-17", "2014-07-11", "2014-07-21"],
+            tz=tz,
+        )
+        exp = DataFrame(0, index=exp_idx, columns=["A", "B"])
+
+        tm.assert_frame_equal(df1._append(df2), exp)
+        tm.assert_frame_equal(pd.concat([df1, df2]), exp)
+
+    def test_concatlike_datetimetz_to_object(self, tz_aware_fixture):
+        tz = tz_aware_fixture
+        # GH 13660
+
+        # different tz coerces to object
+        dti1 = pd.DatetimeIndex(["2011-01-01", "2011-01-02"], tz=tz)
+        dti2 = pd.DatetimeIndex(["2012-01-01", "2012-01-02"])
+
+        exp = Index(
+            [
+                pd.Timestamp("2011-01-01", tz=tz),
+                pd.Timestamp("2011-01-02", tz=tz),
+                pd.Timestamp("2012-01-01"),
+                pd.Timestamp("2012-01-02"),
+            ],
+            dtype=object,
+        )
+
+        res = dti1.append(dti2)
+        tm.assert_index_equal(res, exp)
+
+        dts1 = Series(dti1)
+        dts2 = Series(dti2)
+        res = dts1._append(dts2)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([dts1, dts2])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        # different tz
+        dti3 = pd.DatetimeIndex(["2012-01-01", "2012-01-02"], tz="US/Pacific")
+
+        exp = Index(
+            [
+                pd.Timestamp("2011-01-01", tz=tz),
+                pd.Timestamp("2011-01-02", tz=tz),
+                pd.Timestamp("2012-01-01", tz="US/Pacific"),
+                pd.Timestamp("2012-01-02", tz="US/Pacific"),
+            ],
+            dtype=object,
+        )
+
+        res = dti1.append(dti3)
+        tm.assert_index_equal(res, exp)
+
+        dts1 = Series(dti1)
+        dts3 = Series(dti3)
+        res = dts1._append(dts3)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([dts1, dts3])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+    def test_concatlike_common_period(self):
+        # GH 13660
+        pi1 = pd.PeriodIndex(["2011-01", "2011-02"], freq="M")
+        pi2 = pd.PeriodIndex(["2012-01", "2012-02"], freq="M")
+
+        exp = pd.PeriodIndex(["2011-01", "2011-02", "2012-01", "2012-02"], freq="M")
+
+        res = pi1.append(pi2)
+        tm.assert_index_equal(res, exp)
+
+        ps1 = Series(pi1)
+        ps2 = Series(pi2)
+        res = ps1._append(ps2)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([ps1, ps2])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+    def test_concatlike_common_period_diff_freq_to_object(self):
+        # GH 13221
+        pi1 = pd.PeriodIndex(["2011-01", "2011-02"], freq="M")
+        pi2 = pd.PeriodIndex(["2012-01-01", "2012-02-01"], freq="D")
+
+        exp = Index(
+            [
+                pd.Period("2011-01", freq="M"),
+                pd.Period("2011-02", freq="M"),
+                pd.Period("2012-01-01", freq="D"),
+                pd.Period("2012-02-01", freq="D"),
+            ],
+            dtype=object,
+        )
+
+        res = pi1.append(pi2)
+        tm.assert_index_equal(res, exp)
+
+        ps1 = Series(pi1)
+        ps2 = Series(pi2)
+        res = ps1._append(ps2)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([ps1, ps2])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+    def test_concatlike_common_period_mixed_dt_to_object(self):
+        # GH 13221
+        # different datetimelike
+        pi1 = pd.PeriodIndex(["2011-01", "2011-02"], freq="M")
+        tdi = pd.TimedeltaIndex(["1 days", "2 days"])
+        exp = Index(
+            [
+                pd.Period("2011-01", freq="M"),
+                pd.Period("2011-02", freq="M"),
+                pd.Timedelta("1 days"),
+                pd.Timedelta("2 days"),
+            ],
+            dtype=object,
+        )
+
+        res = pi1.append(tdi)
+        tm.assert_index_equal(res, exp)
+
+        ps1 = Series(pi1)
+        tds = Series(tdi)
+        res = ps1._append(tds)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([ps1, tds])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        # inverse
+        exp = Index(
+            [
+                pd.Timedelta("1 days"),
+                pd.Timedelta("2 days"),
+                pd.Period("2011-01", freq="M"),
+                pd.Period("2011-02", freq="M"),
+            ],
+            dtype=object,
+        )
+
+        res = tdi.append(pi1)
+        tm.assert_index_equal(res, exp)
+
+        ps1 = Series(pi1)
+        tds = Series(tdi)
+        res = tds._append(ps1)
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+        res = pd.concat([tds, ps1])
+        tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
+
+    def test_concat_categorical(self):
+        # GH 13524
+
+        # same categories -> category
+        s1 = Series([1, 2, np.nan], dtype="category")
+        s2 = Series([2, 1, 2], dtype="category")
+
+        exp = Series([1, 2, np.nan, 2, 1, 2], dtype="category")
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        # partially different categories => not-category
+        s1 = Series([3, 2], dtype="category")
+        s2 = Series([2, 1], dtype="category")
+
+        exp = Series([3, 2, 2, 1])
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        # completely different categories (same dtype) => not-category
+        s1 = Series([10, 11, np.nan], dtype="category")
+        s2 = Series([np.nan, 1, 3, 2], dtype="category")
+
+        exp = Series([10, 11, np.nan, np.nan, 1, 3, 2], dtype=np.float64)
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+    def test_union_categorical_same_categories_different_order(self):
+        # https://github.com/pandas-dev/pandas/issues/19096
+        a = Series(Categorical(["a", "b", "c"], categories=["a", "b", "c"]))
+        b = Series(Categorical(["a", "b", "c"], categories=["b", "a", "c"]))
+        result = pd.concat([a, b], ignore_index=True)
+        expected = Series(
+            Categorical(["a", "b", "c", "a", "b", "c"], categories=["a", "b", "c"])
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_categorical_coercion(self):
+        # GH 13524
+
+        # category + not-category => not-category
+        s1 = Series([1, 2, np.nan], dtype="category")
+        s2 = Series([2, 1, 2])
+
+        exp = Series([1, 2, np.nan, 2, 1, 2], dtype=np.float64)
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        # result shouldn't be affected by 1st elem dtype
+        exp = Series([2, 1, 2, 1, 2, np.nan], dtype=np.float64)
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+        # all values are not in category => not-category
+        s1 = Series([3, 2], dtype="category")
+        s2 = Series([2, 1])
+
+        exp = Series([3, 2, 2, 1])
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        exp = Series([2, 1, 3, 2])
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+        # completely different categories => not-category
+        s1 = Series([10, 11, np.nan], dtype="category")
+        s2 = Series([1, 3, 2])
+
+        exp = Series([10, 11, np.nan, 1, 3, 2], dtype=np.float64)
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        exp = Series([1, 3, 2, 10, 11, np.nan], dtype=np.float64)
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+        # different dtype => not-category
+        s1 = Series([10, 11, np.nan], dtype="category")
+        s2 = Series(["a", "b", "c"])
+
+        exp = Series([10, 11, np.nan, "a", "b", "c"])
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        exp = Series(["a", "b", "c", 10, 11, np.nan])
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+        # if normal series only contains NaN-likes => not-category
+        s1 = Series([10, 11], dtype="category")
+        s2 = Series([np.nan, np.nan, np.nan])
+
+        exp = Series([10, 11, np.nan, np.nan, np.nan])
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        exp = Series([np.nan, np.nan, np.nan, 10, 11])
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+    def test_concat_categorical_3elem_coercion(self):
+        # GH 13524
+
+        # mixed dtypes => not-category
+        s1 = Series([1, 2, np.nan], dtype="category")
+        s2 = Series([2, 1, 2], dtype="category")
+        s3 = Series([1, 2, 1, 2, np.nan])
+
+        exp = Series([1, 2, np.nan, 2, 1, 2, 1, 2, 1, 2, np.nan], dtype="float")
+        tm.assert_series_equal(pd.concat([s1, s2, s3], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append([s2, s3], ignore_index=True), exp)
+
+        exp = Series([1, 2, 1, 2, np.nan, 1, 2, np.nan, 2, 1, 2], dtype="float")
+        tm.assert_series_equal(pd.concat([s3, s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s3._append([s1, s2], ignore_index=True), exp)
+
+        # values are all in either category => not-category
+        s1 = Series([4, 5, 6], dtype="category")
+        s2 = Series([1, 2, 3], dtype="category")
+        s3 = Series([1, 3, 4])
+
+        exp = Series([4, 5, 6, 1, 2, 3, 1, 3, 4])
+        tm.assert_series_equal(pd.concat([s1, s2, s3], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append([s2, s3], ignore_index=True), exp)
+
+        exp = Series([1, 3, 4, 4, 5, 6, 1, 2, 3])
+        tm.assert_series_equal(pd.concat([s3, s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s3._append([s1, s2], ignore_index=True), exp)
+
+        # values are all in either category => not-category
+        s1 = Series([4, 5, 6], dtype="category")
+        s2 = Series([1, 2, 3], dtype="category")
+        s3 = Series([10, 11, 12])
+
+        exp = Series([4, 5, 6, 1, 2, 3, 10, 11, 12])
+        tm.assert_series_equal(pd.concat([s1, s2, s3], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append([s2, s3], ignore_index=True), exp)
+
+        exp = Series([10, 11, 12, 4, 5, 6, 1, 2, 3])
+        tm.assert_series_equal(pd.concat([s3, s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s3._append([s1, s2], ignore_index=True), exp)
+
+    def test_concat_categorical_multi_coercion(self):
+        # GH 13524
+
+        s1 = Series([1, 3], dtype="category")
+        s2 = Series([3, 4], dtype="category")
+        s3 = Series([2, 3])
+        s4 = Series([2, 2], dtype="category")
+        s5 = Series([1, np.nan])
+        s6 = Series([1, 3, 2], dtype="category")
+
+        # mixed dtype, values are all in categories => not-category
+        exp = Series([1, 3, 3, 4, 2, 3, 2, 2, 1, np.nan, 1, 3, 2])
+        res = pd.concat([s1, s2, s3, s4, s5, s6], ignore_index=True)
+        tm.assert_series_equal(res, exp)
+        res = s1._append([s2, s3, s4, s5, s6], ignore_index=True)
+        tm.assert_series_equal(res, exp)
+
+        exp = Series([1, 3, 2, 1, np.nan, 2, 2, 2, 3, 3, 4, 1, 3])
+        res = pd.concat([s6, s5, s4, s3, s2, s1], ignore_index=True)
+        tm.assert_series_equal(res, exp)
+        res = s6._append([s5, s4, s3, s2, s1], ignore_index=True)
+        tm.assert_series_equal(res, exp)
+
+    def test_concat_categorical_ordered(self):
+        # GH 13524
+
+        s1 = Series(Categorical([1, 2, np.nan], ordered=True))
+        s2 = Series(Categorical([2, 1, 2], ordered=True))
+
+        exp = Series(Categorical([1, 2, np.nan, 2, 1, 2], ordered=True))
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        exp = Series(Categorical([1, 2, np.nan, 2, 1, 2, 1, 2, np.nan], ordered=True))
+        tm.assert_series_equal(pd.concat([s1, s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append([s2, s1], ignore_index=True), exp)
+
+    def test_concat_categorical_coercion_nan(self):
+        # GH 13524
+
+        # some edge cases
+        # category + not-category => not category
+        s1 = Series(np.array([np.nan, np.nan], dtype=np.float64), dtype="category")
+        s2 = Series([np.nan, 1])
+
+        exp = Series([np.nan, np.nan, np.nan, 1])
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        s1 = Series([1, np.nan], dtype="category")
+        s2 = Series([np.nan, np.nan])
+
+        exp = Series([1, np.nan, np.nan, np.nan], dtype="float")
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        # mixed dtype, all nan-likes => not-category
+        s1 = Series([np.nan, np.nan], dtype="category")
+        s2 = Series([np.nan, np.nan])
+
+        exp = Series([np.nan, np.nan, np.nan, np.nan])
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+        # all category nan-likes => category
+        s1 = Series([np.nan, np.nan], dtype="category")
+        s2 = Series([np.nan, np.nan], dtype="category")
+
+        exp = Series([np.nan, np.nan, np.nan, np.nan], dtype="category")
+
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+    def test_concat_categorical_empty(self):
+        # GH 13524
+
+        s1 = Series([], dtype="category")
+        s2 = Series([1, 2], dtype="category")
+
+        msg = "The behavior of array concatenation with empty entries is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), s2)
+            tm.assert_series_equal(s1._append(s2, ignore_index=True), s2)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), s2)
+            tm.assert_series_equal(s2._append(s1, ignore_index=True), s2)
+
+        s1 = Series([], dtype="category")
+        s2 = Series([], dtype="category")
+
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), s2)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), s2)
+
+        s1 = Series([], dtype="category")
+        s2 = Series([], dtype="object")
+
+        # different dtype => not-category
+        tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), s2)
+        tm.assert_series_equal(s1._append(s2, ignore_index=True), s2)
+        tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), s2)
+        tm.assert_series_equal(s2._append(s1, ignore_index=True), s2)
+
+        s1 = Series([], dtype="category")
+        s2 = Series([np.nan, np.nan])
+
+        # empty Series is ignored
+        exp = Series([np.nan, np.nan])
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_series_equal(pd.concat([s1, s2], ignore_index=True), exp)
+            tm.assert_series_equal(s1._append(s2, ignore_index=True), exp)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
+            tm.assert_series_equal(s2._append(s1, ignore_index=True), exp)
+
+    def test_categorical_concat_append(self):
+        cat = Categorical(["a", "b"], categories=["a", "b"])
+        vals = [1, 2]
+        df = DataFrame({"cats": cat, "vals": vals})
+        cat2 = Categorical(["a", "b", "a", "b"], categories=["a", "b"])
+        vals2 = [1, 2, 1, 2]
+        exp = DataFrame({"cats": cat2, "vals": vals2}, index=Index([0, 1, 0, 1]))
+
+        tm.assert_frame_equal(pd.concat([df, df]), exp)
+        tm.assert_frame_equal(df._append(df), exp)
+
+        # GH 13524 can concat different categories
+        cat3 = Categorical(["a", "b"], categories=["a", "b", "c"])
+        vals3 = [1, 2]
+        df_different_categories = DataFrame({"cats": cat3, "vals": vals3})
+
+        res = pd.concat([df, df_different_categories], ignore_index=True)
+        exp = DataFrame({"cats": list("abab"), "vals": [1, 2, 1, 2]})
+        tm.assert_frame_equal(res, exp)
+
+        res = df._append(df_different_categories, ignore_index=True)
+        tm.assert_frame_equal(res, exp)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_categorical.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_categorical.py
new file mode 100644
index 0000000000000000000000000000000000000000..2730b2ffcc4e3f8fd641916c2505b75a8fa157d9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_categorical.py
@@ -0,0 +1,271 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestCategoricalConcat:
+    def test_categorical_concat(self, sort):
+        # See GH 10177
+        df1 = DataFrame(
+            np.arange(18, dtype="int64").reshape(6, 3), columns=["a", "b", "c"]
+        )
+
+        df2 = DataFrame(np.arange(14, dtype="int64").reshape(7, 2), columns=["a", "c"])
+
+        cat_values = ["one", "one", "two", "one", "two", "two", "one"]
+        df2["h"] = Series(Categorical(cat_values))
+
+        res = pd.concat((df1, df2), axis=0, ignore_index=True, sort=sort)
+        exp = DataFrame(
+            {
+                "a": [0, 3, 6, 9, 12, 15, 0, 2, 4, 6, 8, 10, 12],
+                "b": [
+                    1,
+                    4,
+                    7,
+                    10,
+                    13,
+                    16,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                    np.nan,
+                ],
+                "c": [2, 5, 8, 11, 14, 17, 1, 3, 5, 7, 9, 11, 13],
+                "h": [None] * 6 + cat_values,
+            }
+        )
+        exp["h"] = exp["h"].astype(df2["h"].dtype)
+        tm.assert_frame_equal(res, exp)
+
+    def test_categorical_concat_dtypes(self):
+        # GH8143
+        index = ["cat", "obj", "num"]
+        cat = Categorical(["a", "b", "c"])
+        obj = Series(["a", "b", "c"])
+        num = Series([1, 2, 3])
+        df = pd.concat([Series(cat), obj, num], axis=1, keys=index)
+
+        result = df.dtypes == "object"
+        expected = Series([False, True, False], index=index)
+        tm.assert_series_equal(result, expected)
+
+        result = df.dtypes == "int64"
+        expected = Series([False, False, True], index=index)
+        tm.assert_series_equal(result, expected)
+
+        result = df.dtypes == "category"
+        expected = Series([True, False, False], index=index)
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_categoricalindex(self):
+        # GH 16111, categories that aren't lexsorted
+        categories = [9, 0, 1, 2, 3]
+
+        a = Series(1, index=pd.CategoricalIndex([9, 0], categories=categories))
+        b = Series(2, index=pd.CategoricalIndex([0, 1], categories=categories))
+        c = Series(3, index=pd.CategoricalIndex([1, 2], categories=categories))
+
+        result = pd.concat([a, b, c], axis=1)
+
+        exp_idx = pd.CategoricalIndex([9, 0, 1, 2], categories=categories)
+        exp = DataFrame(
+            {
+                0: [1, 1, np.nan, np.nan],
+                1: [np.nan, 2, 2, np.nan],
+                2: [np.nan, np.nan, 3, 3],
+            },
+            columns=[0, 1, 2],
+            index=exp_idx,
+        )
+        tm.assert_frame_equal(result, exp)
+
+    def test_categorical_concat_preserve(self):
+        # GH 8641  series concat not preserving category dtype
+        # GH 13524 can concat different categories
+        s = Series(list("abc"), dtype="category")
+        s2 = Series(list("abd"), dtype="category")
+
+        exp = Series(list("abcabd"))
+        res = pd.concat([s, s2], ignore_index=True)
+        tm.assert_series_equal(res, exp)
+
+        exp = Series(list("abcabc"), dtype="category")
+        res = pd.concat([s, s], ignore_index=True)
+        tm.assert_series_equal(res, exp)
+
+        exp = Series(list("abcabc"), index=[0, 1, 2, 0, 1, 2], dtype="category")
+        res = pd.concat([s, s])
+        tm.assert_series_equal(res, exp)
+
+        a = Series(np.arange(6, dtype="int64"))
+        b = Series(list("aabbca"))
+
+        df2 = DataFrame({"A": a, "B": b.astype(CategoricalDtype(list("cab")))})
+        res = pd.concat([df2, df2])
+        exp = DataFrame(
+            {
+                "A": pd.concat([a, a]),
+                "B": pd.concat([b, b]).astype(CategoricalDtype(list("cab"))),
+            }
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_categorical_index_preserver(self):
+        a = Series(np.arange(6, dtype="int64"))
+        b = Series(list("aabbca"))
+
+        df2 = DataFrame(
+            {"A": a, "B": b.astype(CategoricalDtype(list("cab")))}
+        ).set_index("B")
+        result = pd.concat([df2, df2])
+        expected = DataFrame(
+            {
+                "A": pd.concat([a, a]),
+                "B": pd.concat([b, b]).astype(CategoricalDtype(list("cab"))),
+            }
+        ).set_index("B")
+        tm.assert_frame_equal(result, expected)
+
+        # wrong categories -> uses concat_compat, which casts to object
+        df3 = DataFrame(
+            {"A": a, "B": Categorical(b, categories=list("abe"))}
+        ).set_index("B")
+        result = pd.concat([df2, df3])
+        expected = pd.concat(
+            [
+                df2.set_axis(df2.index.astype(object), axis=0),
+                df3.set_axis(df3.index.astype(object), axis=0),
+            ]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_categorical_tz(self):
+        # GH-23816
+        a = Series(pd.date_range("2017-01-01", periods=2, tz="US/Pacific"))
+        b = Series(["a", "b"], dtype="category")
+        result = pd.concat([a, b], ignore_index=True)
+        expected = Series(
+            [
+                pd.Timestamp("2017-01-01", tz="US/Pacific"),
+                pd.Timestamp("2017-01-02", tz="US/Pacific"),
+                "a",
+                "b",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_categorical_datetime(self):
+        # GH-39443
+        df1 = DataFrame(
+            {"x": Series(datetime(2021, 1, 1), index=[0], dtype="category")}
+        )
+        df2 = DataFrame(
+            {"x": Series(datetime(2021, 1, 2), index=[1], dtype="category")}
+        )
+
+        result = pd.concat([df1, df2])
+        expected = DataFrame(
+            {"x": Series([datetime(2021, 1, 1), datetime(2021, 1, 2)])}
+        )
+
+        tm.assert_equal(result, expected)
+
+    def test_concat_categorical_unchanged(self):
+        # GH-12007
+        # test fix for when concat on categorical and float
+        # coerces dtype categorical -> float
+        df = DataFrame(Series(["a", "b", "c"], dtype="category", name="A"))
+        ser = Series([0, 1, 2], index=[0, 1, 3], name="B")
+        result = pd.concat([df, ser], axis=1)
+        expected = DataFrame(
+            {
+                "A": Series(["a", "b", "c", np.nan], dtype="category"),
+                "B": Series([0, 1, np.nan, 2], dtype="float"),
+            }
+        )
+        tm.assert_equal(result, expected)
+
+    def test_categorical_concat_gh7864(self):
+        # GH 7864
+        # make sure ordering is preserved
+        df = DataFrame({"id": [1, 2, 3, 4, 5, 6], "raw_grade": list("abbaae")})
+        df["grade"] = Categorical(df["raw_grade"])
+        df["grade"].cat.set_categories(["e", "a", "b"])
+
+        df1 = df[0:3]
+        df2 = df[3:]
+
+        tm.assert_index_equal(df["grade"].cat.categories, df1["grade"].cat.categories)
+        tm.assert_index_equal(df["grade"].cat.categories, df2["grade"].cat.categories)
+
+        dfx = pd.concat([df1, df2])
+        tm.assert_index_equal(df["grade"].cat.categories, dfx["grade"].cat.categories)
+
+        dfa = df1._append(df2)
+        tm.assert_index_equal(df["grade"].cat.categories, dfa["grade"].cat.categories)
+
+    def test_categorical_index_upcast(self):
+        # GH 17629
+        # test upcasting to object when concatinating on categorical indexes
+        # with non-identical categories
+
+        a = DataFrame({"foo": [1, 2]}, index=Categorical(["foo", "bar"]))
+        b = DataFrame({"foo": [4, 3]}, index=Categorical(["baz", "bar"]))
+
+        res = pd.concat([a, b])
+        exp = DataFrame({"foo": [1, 2, 4, 3]}, index=["foo", "bar", "baz", "bar"])
+
+        tm.assert_equal(res, exp)
+
+        a = Series([1, 2], index=Categorical(["foo", "bar"]))
+        b = Series([4, 3], index=Categorical(["baz", "bar"]))
+
+        res = pd.concat([a, b])
+        exp = Series([1, 2, 4, 3], index=["foo", "bar", "baz", "bar"])
+
+        tm.assert_equal(res, exp)
+
+    def test_categorical_missing_from_one_frame(self):
+        # GH 25412
+        df1 = DataFrame({"f1": [1, 2, 3]})
+        df2 = DataFrame({"f1": [2, 3, 1], "f2": Series([4, 4, 4]).astype("category")})
+        result = pd.concat([df1, df2], sort=True)
+        dtype = CategoricalDtype([4])
+        expected = DataFrame(
+            {
+                "f1": [1, 2, 3, 2, 3, 1],
+                "f2": Categorical.from_codes([-1, -1, -1, 0, 0, 0], dtype=dtype),
+            },
+            index=[0, 1, 2, 0, 1, 2],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_categorical_same_categories_different_order(self):
+        # https://github.com/pandas-dev/pandas/issues/24845
+
+        c1 = pd.CategoricalIndex(["a", "a"], categories=["a", "b"], ordered=False)
+        c2 = pd.CategoricalIndex(["b", "b"], categories=["b", "a"], ordered=False)
+        c3 = pd.CategoricalIndex(
+            ["a", "a", "b", "b"], categories=["a", "b"], ordered=False
+        )
+
+        df1 = DataFrame({"A": [1, 2]}, index=c1)
+        df2 = DataFrame({"A": [3, 4]}, index=c2)
+
+        result = pd.concat((df1, df2))
+        expected = DataFrame({"A": [1, 2, 3, 4]}, index=c3)
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_concat.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_concat.py
new file mode 100644
index 0000000000000000000000000000000000000000..7863aa55152f15b1d9398c5de00d0d8c5de3f435
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_concat.py
@@ -0,0 +1,872 @@
+from collections import (
+    abc,
+    deque,
+)
+from collections.abc import Iterator
+from datetime import datetime
+from decimal import Decimal
+
+import numpy as np
+import pytest
+
+from pandas.errors import InvalidIndexError
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    PeriodIndex,
+    Series,
+    concat,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import SparseArray
+from pandas.tests.extension.decimal import to_decimal
+
+
+class TestConcatenate:
+    def test_append_concat(self):
+        # GH#1815
+        d1 = date_range("12/31/1990", "12/31/1999", freq="A-DEC")
+        d2 = date_range("12/31/2000", "12/31/2009", freq="A-DEC")
+
+        s1 = Series(np.random.default_rng(2).standard_normal(10), d1)
+        s2 = Series(np.random.default_rng(2).standard_normal(10), d2)
+
+        s1 = s1.to_period()
+        s2 = s2.to_period()
+
+        # drops index
+        result = concat([s1, s2])
+        assert isinstance(result.index, PeriodIndex)
+        assert result.index[0] == s1.index[0]
+
+    def test_concat_copy(self, using_array_manager, using_copy_on_write):
+        df = DataFrame(np.random.default_rng(2).standard_normal((4, 3)))
+        df2 = DataFrame(np.random.default_rng(2).integers(0, 10, size=4).reshape(4, 1))
+        df3 = DataFrame({5: "foo"}, index=range(4))
+
+        # These are actual copies.
+        result = concat([df, df2, df3], axis=1, copy=True)
+
+        if not using_copy_on_write:
+            for arr in result._mgr.arrays:
+                assert not any(
+                    np.shares_memory(arr, y)
+                    for x in [df, df2, df3]
+                    for y in x._mgr.arrays
+                )
+        else:
+            for arr in result._mgr.arrays:
+                assert arr.base is not None
+
+        # These are the same.
+        result = concat([df, df2, df3], axis=1, copy=False)
+
+        for arr in result._mgr.arrays:
+            if arr.dtype.kind == "f":
+                assert arr.base is df._mgr.arrays[0].base
+            elif arr.dtype.kind in ["i", "u"]:
+                assert arr.base is df2._mgr.arrays[0].base
+            elif arr.dtype == object:
+                if using_array_manager:
+                    # we get the same array object, which has no base
+                    assert arr is df3._mgr.arrays[0]
+                else:
+                    assert arr.base is not None
+
+        # Float block was consolidated.
+        df4 = DataFrame(np.random.default_rng(2).standard_normal((4, 1)))
+        result = concat([df, df2, df3, df4], axis=1, copy=False)
+        for arr in result._mgr.arrays:
+            if arr.dtype.kind == "f":
+                if using_array_manager or using_copy_on_write:
+                    # this is a view on some array in either df or df4
+                    assert any(
+                        np.shares_memory(arr, other)
+                        for other in df._mgr.arrays + df4._mgr.arrays
+                    )
+                else:
+                    # the block was consolidated, so we got a copy anyway
+                    assert arr.base is None
+            elif arr.dtype.kind in ["i", "u"]:
+                assert arr.base is df2._mgr.arrays[0].base
+            elif arr.dtype == object:
+                # this is a view on df3
+                assert any(np.shares_memory(arr, other) for other in df3._mgr.arrays)
+
+    def test_concat_with_group_keys(self):
+        # axis=0
+        df = DataFrame(np.random.default_rng(2).standard_normal((3, 4)))
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((4, 4)))
+
+        result = concat([df, df2], keys=[0, 1])
+        exp_index = MultiIndex.from_arrays(
+            [[0, 0, 0, 1, 1, 1, 1], [0, 1, 2, 0, 1, 2, 3]]
+        )
+        expected = DataFrame(np.r_[df.values, df2.values], index=exp_index)
+        tm.assert_frame_equal(result, expected)
+
+        result = concat([df, df], keys=[0, 1])
+        exp_index2 = MultiIndex.from_arrays([[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]])
+        expected = DataFrame(np.r_[df.values, df.values], index=exp_index2)
+        tm.assert_frame_equal(result, expected)
+
+        # axis=1
+        df = DataFrame(np.random.default_rng(2).standard_normal((4, 3)))
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((4, 4)))
+
+        result = concat([df, df2], keys=[0, 1], axis=1)
+        expected = DataFrame(np.c_[df.values, df2.values], columns=exp_index)
+        tm.assert_frame_equal(result, expected)
+
+        result = concat([df, df], keys=[0, 1], axis=1)
+        expected = DataFrame(np.c_[df.values, df.values], columns=exp_index2)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_keys_specific_levels(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+        pieces = [df.iloc[:, [0, 1]], df.iloc[:, [2]], df.iloc[:, [3]]]
+        level = ["three", "two", "one", "zero"]
+        result = concat(
+            pieces,
+            axis=1,
+            keys=["one", "two", "three"],
+            levels=[level],
+            names=["group_key"],
+        )
+
+        tm.assert_index_equal(result.columns.levels[0], Index(level, name="group_key"))
+        tm.assert_index_equal(result.columns.levels[1], Index([0, 1, 2, 3]))
+
+        assert result.columns.names == ["group_key", None]
+
+    @pytest.mark.parametrize("mapping", ["mapping", "dict"])
+    def test_concat_mapping(self, mapping, non_dict_mapping_subclass):
+        constructor = dict if mapping == "dict" else non_dict_mapping_subclass
+        frames = constructor(
+            {
+                "foo": DataFrame(np.random.default_rng(2).standard_normal((4, 3))),
+                "bar": DataFrame(np.random.default_rng(2).standard_normal((4, 3))),
+                "baz": DataFrame(np.random.default_rng(2).standard_normal((4, 3))),
+                "qux": DataFrame(np.random.default_rng(2).standard_normal((4, 3))),
+            }
+        )
+
+        sorted_keys = list(frames.keys())
+
+        result = concat(frames)
+        expected = concat([frames[k] for k in sorted_keys], keys=sorted_keys)
+        tm.assert_frame_equal(result, expected)
+
+        result = concat(frames, axis=1)
+        expected = concat([frames[k] for k in sorted_keys], keys=sorted_keys, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        keys = ["baz", "foo", "bar"]
+        result = concat(frames, keys=keys)
+        expected = concat([frames[k] for k in keys], keys=keys)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_keys_and_levels(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((1, 3)))
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((1, 4)))
+
+        levels = [["foo", "baz"], ["one", "two"]]
+        names = ["first", "second"]
+        result = concat(
+            [df, df2, df, df2],
+            keys=[("foo", "one"), ("foo", "two"), ("baz", "one"), ("baz", "two")],
+            levels=levels,
+            names=names,
+        )
+        expected = concat([df, df2, df, df2])
+        exp_index = MultiIndex(
+            levels=levels + [[0]],
+            codes=[[0, 0, 1, 1], [0, 1, 0, 1], [0, 0, 0, 0]],
+            names=names + [None],
+        )
+        expected.index = exp_index
+
+        tm.assert_frame_equal(result, expected)
+
+        # no names
+        result = concat(
+            [df, df2, df, df2],
+            keys=[("foo", "one"), ("foo", "two"), ("baz", "one"), ("baz", "two")],
+            levels=levels,
+        )
+        assert result.index.names == (None,) * 3
+
+        # no levels
+        result = concat(
+            [df, df2, df, df2],
+            keys=[("foo", "one"), ("foo", "two"), ("baz", "one"), ("baz", "two")],
+            names=["first", "second"],
+        )
+        assert result.index.names == ("first", "second", None)
+        tm.assert_index_equal(
+            result.index.levels[0], Index(["baz", "foo"], name="first")
+        )
+
+    def test_concat_keys_levels_no_overlap(self):
+        # GH #1406
+        df = DataFrame(np.random.default_rng(2).standard_normal((1, 3)), index=["a"])
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((1, 4)), index=["b"])
+
+        msg = "Values not found in passed level"
+        with pytest.raises(ValueError, match=msg):
+            concat([df, df], keys=["one", "two"], levels=[["foo", "bar", "baz"]])
+
+        msg = "Key one not in level"
+        with pytest.raises(ValueError, match=msg):
+            concat([df, df2], keys=["one", "two"], levels=[["foo", "bar", "baz"]])
+
+    def test_crossed_dtypes_weird_corner(self):
+        columns = ["A", "B", "C", "D"]
+        df1 = DataFrame(
+            {
+                "A": np.array([1, 2, 3, 4], dtype="f8"),
+                "B": np.array([1, 2, 3, 4], dtype="i8"),
+                "C": np.array([1, 2, 3, 4], dtype="f8"),
+                "D": np.array([1, 2, 3, 4], dtype="i8"),
+            },
+            columns=columns,
+        )
+
+        df2 = DataFrame(
+            {
+                "A": np.array([1, 2, 3, 4], dtype="i8"),
+                "B": np.array([1, 2, 3, 4], dtype="f8"),
+                "C": np.array([1, 2, 3, 4], dtype="i8"),
+                "D": np.array([1, 2, 3, 4], dtype="f8"),
+            },
+            columns=columns,
+        )
+
+        appended = concat([df1, df2], ignore_index=True)
+        expected = DataFrame(
+            np.concatenate([df1.values, df2.values], axis=0), columns=columns
+        )
+        tm.assert_frame_equal(appended, expected)
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((1, 3)), index=["a"])
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((1, 4)), index=["b"])
+        result = concat([df, df2], keys=["one", "two"], names=["first", "second"])
+        assert result.index.names == ("first", "second")
+
+    def test_with_mixed_tuples(self, sort):
+        # 10697
+        # columns have mixed tuples, so handle properly
+        df1 = DataFrame({"A": "foo", ("B", 1): "bar"}, index=range(2))
+        df2 = DataFrame({"B": "foo", ("B", 1): "bar"}, index=range(2))
+
+        # it works
+        concat([df1, df2], sort=sort)
+
+    def test_concat_mixed_objs(self):
+        # concat mixed series/frames
+        # G2385
+
+        # axis 1
+        index = date_range("01-Jan-2013", periods=10, freq="H")
+        arr = np.arange(10, dtype="int64")
+        s1 = Series(arr, index=index)
+        s2 = Series(arr, index=index)
+        df = DataFrame(arr.reshape(-1, 1), index=index)
+
+        expected = DataFrame(
+            np.repeat(arr, 2).reshape(-1, 2), index=index, columns=[0, 0]
+        )
+        result = concat([df, df], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame(
+            np.repeat(arr, 2).reshape(-1, 2), index=index, columns=[0, 1]
+        )
+        result = concat([s1, s2], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame(
+            np.repeat(arr, 3).reshape(-1, 3), index=index, columns=[0, 1, 2]
+        )
+        result = concat([s1, s2, s1], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame(
+            np.repeat(arr, 5).reshape(-1, 5), index=index, columns=[0, 0, 1, 2, 3]
+        )
+        result = concat([s1, df, s2, s2, s1], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        # with names
+        s1.name = "foo"
+        expected = DataFrame(
+            np.repeat(arr, 3).reshape(-1, 3), index=index, columns=["foo", 0, 0]
+        )
+        result = concat([s1, df, s2], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        s2.name = "bar"
+        expected = DataFrame(
+            np.repeat(arr, 3).reshape(-1, 3), index=index, columns=["foo", 0, "bar"]
+        )
+        result = concat([s1, df, s2], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        # ignore index
+        expected = DataFrame(
+            np.repeat(arr, 3).reshape(-1, 3), index=index, columns=[0, 1, 2]
+        )
+        result = concat([s1, df, s2], axis=1, ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+        # axis 0
+        expected = DataFrame(
+            np.tile(arr, 3).reshape(-1, 1), index=index.tolist() * 3, columns=[0]
+        )
+        result = concat([s1, df, s2])
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame(np.tile(arr, 3).reshape(-1, 1), columns=[0])
+        result = concat([s1, df, s2], ignore_index=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_dtype_coercion(self):
+        # 12411
+        df = DataFrame({"date": [pd.Timestamp("20130101").tz_localize("UTC"), pd.NaT]})
+
+        result = concat([df.iloc[[0]], df.iloc[[1]]])
+        tm.assert_series_equal(result.dtypes, df.dtypes)
+
+        # 12045
+        df = DataFrame({"date": [datetime(2012, 1, 1), datetime(1012, 1, 2)]})
+        result = concat([df.iloc[[0]], df.iloc[[1]]])
+        tm.assert_series_equal(result.dtypes, df.dtypes)
+
+        # 11594
+        df = DataFrame({"text": ["some words"] + [None] * 9})
+        result = concat([df.iloc[[0]], df.iloc[[1]]])
+        tm.assert_series_equal(result.dtypes, df.dtypes)
+
+    def test_concat_single_with_key(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+
+        result = concat([df], keys=["foo"])
+        expected = concat([df, df], keys=["foo", "bar"])
+        tm.assert_frame_equal(result, expected[:10])
+
+    def test_concat_no_items_raises(self):
+        with pytest.raises(ValueError, match="No objects to concatenate"):
+            concat([])
+
+    def test_concat_exclude_none(self):
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+
+        pieces = [df[:5], None, None, df[5:]]
+        result = concat(pieces)
+        tm.assert_frame_equal(result, df)
+        with pytest.raises(ValueError, match="All objects passed were None"):
+            concat([None, None])
+
+    def test_concat_keys_with_none(self):
+        # #1649
+        df0 = DataFrame([[10, 20, 30], [10, 20, 30], [10, 20, 30]])
+
+        result = concat({"a": None, "b": df0, "c": df0[:2], "d": df0[:1], "e": df0})
+        expected = concat({"b": df0, "c": df0[:2], "d": df0[:1], "e": df0})
+        tm.assert_frame_equal(result, expected)
+
+        result = concat(
+            [None, df0, df0[:2], df0[:1], df0], keys=["a", "b", "c", "d", "e"]
+        )
+        expected = concat([df0, df0[:2], df0[:1], df0], keys=["b", "c", "d", "e"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_bug_1719(self):
+        ts1 = tm.makeTimeSeries()
+        ts2 = tm.makeTimeSeries()[::2]
+
+        # to join with union
+        # these two are of different length!
+        left = concat([ts1, ts2], join="outer", axis=1)
+        right = concat([ts2, ts1], join="outer", axis=1)
+
+        assert len(left) == len(right)
+
+    def test_concat_bug_2972(self):
+        ts0 = Series(np.zeros(5))
+        ts1 = Series(np.ones(5))
+        ts0.name = ts1.name = "same name"
+        result = concat([ts0, ts1], axis=1)
+
+        expected = DataFrame({0: ts0, 1: ts1})
+        expected.columns = ["same name", "same name"]
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_bug_3602(self):
+        # GH 3602, duplicate columns
+        df1 = DataFrame(
+            {
+                "firmNo": [0, 0, 0, 0],
+                "prc": [6, 6, 6, 6],
+                "stringvar": ["rrr", "rrr", "rrr", "rrr"],
+            }
+        )
+        df2 = DataFrame(
+            {"C": [9, 10, 11, 12], "misc": [1, 2, 3, 4], "prc": [6, 6, 6, 6]}
+        )
+        expected = DataFrame(
+            [
+                [0, 6, "rrr", 9, 1, 6],
+                [0, 6, "rrr", 10, 2, 6],
+                [0, 6, "rrr", 11, 3, 6],
+                [0, 6, "rrr", 12, 4, 6],
+            ]
+        )
+        expected.columns = ["firmNo", "prc", "stringvar", "C", "misc", "prc"]
+
+        result = concat([df1, df2], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_iterables(self):
+        # GH8645 check concat works with tuples, list, generators, and weird
+        # stuff like deque and custom iterables
+        df1 = DataFrame([1, 2, 3])
+        df2 = DataFrame([4, 5, 6])
+        expected = DataFrame([1, 2, 3, 4, 5, 6])
+        tm.assert_frame_equal(concat((df1, df2), ignore_index=True), expected)
+        tm.assert_frame_equal(concat([df1, df2], ignore_index=True), expected)
+        tm.assert_frame_equal(
+            concat((df for df in (df1, df2)), ignore_index=True), expected
+        )
+        tm.assert_frame_equal(concat(deque((df1, df2)), ignore_index=True), expected)
+
+        class CustomIterator1:
+            def __len__(self) -> int:
+                return 2
+
+            def __getitem__(self, index):
+                try:
+                    return {0: df1, 1: df2}[index]
+                except KeyError as err:
+                    raise IndexError from err
+
+        tm.assert_frame_equal(concat(CustomIterator1(), ignore_index=True), expected)
+
+        class CustomIterator2(abc.Iterable):
+            def __iter__(self) -> Iterator:
+                yield df1
+                yield df2
+
+        tm.assert_frame_equal(concat(CustomIterator2(), ignore_index=True), expected)
+
+    def test_concat_order(self):
+        # GH 17344, GH#47331
+        dfs = [DataFrame(index=range(3), columns=["a", 1, None])]
+        dfs += [DataFrame(index=range(3), columns=[None, 1, "a"]) for _ in range(100)]
+
+        result = concat(dfs, sort=True).columns
+        expected = Index([1, "a", None])
+        tm.assert_index_equal(result, expected)
+
+    def test_concat_different_extension_dtypes_upcasts(self):
+        a = Series(pd.array([1, 2], dtype="Int64"))
+        b = Series(to_decimal([1, 2]))
+
+        result = concat([a, b], ignore_index=True)
+        expected = Series([1, 2, Decimal(1), Decimal(2)], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_ordered_dict(self):
+        # GH 21510
+        expected = concat(
+            [Series(range(3)), Series(range(4))], keys=["First", "Another"]
+        )
+        result = concat({"First": Series(range(3)), "Another": Series(range(4))})
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_duplicate_indices_raise(self):
+        # GH 45888: test raise for concat DataFrames with duplicate indices
+        # https://github.com/pandas-dev/pandas/issues/36263
+        df1 = DataFrame(
+            np.random.default_rng(2).standard_normal(5),
+            index=[0, 1, 2, 3, 3],
+            columns=["a"],
+        )
+        df2 = DataFrame(
+            np.random.default_rng(2).standard_normal(5),
+            index=[0, 1, 2, 2, 4],
+            columns=["b"],
+        )
+        msg = "Reindexing only valid with uniquely valued Index objects"
+        with pytest.raises(InvalidIndexError, match=msg):
+            concat([df1, df2], axis=1)
+
+
+def test_concat_no_unnecessary_upcast(float_numpy_dtype, frame_or_series):
+    # GH 13247
+    dims = frame_or_series(dtype=object).ndim
+    dt = float_numpy_dtype
+
+    dfs = [
+        frame_or_series(np.array([1], dtype=dt, ndmin=dims)),
+        frame_or_series(np.array([np.nan], dtype=dt, ndmin=dims)),
+        frame_or_series(np.array([5], dtype=dt, ndmin=dims)),
+    ]
+    x = concat(dfs)
+    assert x.values.dtype == dt
+
+
+@pytest.mark.parametrize("pdt", [Series, DataFrame])
+def test_concat_will_upcast(pdt, any_signed_int_numpy_dtype):
+    dt = any_signed_int_numpy_dtype
+    dims = pdt().ndim
+    dfs = [
+        pdt(np.array([1], dtype=dt, ndmin=dims)),
+        pdt(np.array([np.nan], ndmin=dims)),
+        pdt(np.array([5], dtype=dt, ndmin=dims)),
+    ]
+    x = concat(dfs)
+    assert x.values.dtype == "float64"
+
+
+def test_concat_empty_and_non_empty_frame_regression():
+    # GH 18178 regression test
+    df1 = DataFrame({"foo": [1]})
+    df2 = DataFrame({"foo": []})
+    expected = DataFrame({"foo": [1.0]})
+    result = concat([df1, df2])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_sparse():
+    # GH 23557
+    a = Series(SparseArray([0, 1, 2]))
+    expected = DataFrame(data=[[0, 0], [1, 1], [2, 2]]).astype(
+        pd.SparseDtype(np.int64, 0)
+    )
+    result = concat([a, a], axis=1)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_dense_sparse():
+    # GH 30668
+    dtype = pd.SparseDtype(np.float64, None)
+    a = Series(pd.arrays.SparseArray([1, None]), dtype=dtype)
+    b = Series([1], dtype=float)
+    expected = Series(data=[1, None, 1], index=[0, 1, 0]).astype(dtype)
+    result = concat([a, b], axis=0)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("keys", [["e", "f", "f"], ["f", "e", "f"]])
+def test_duplicate_keys(keys):
+    # GH 33654
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    s1 = Series([7, 8, 9], name="c")
+    s2 = Series([10, 11, 12], name="d")
+    result = concat([df, s1, s2], axis=1, keys=keys)
+    expected_values = [[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]
+    expected_columns = MultiIndex.from_tuples(
+        [(keys[0], "a"), (keys[0], "b"), (keys[1], "c"), (keys[2], "d")]
+    )
+    expected = DataFrame(expected_values, columns=expected_columns)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_duplicate_keys_same_frame():
+    # GH 43595
+    keys = ["e", "e"]
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    result = concat([df, df], axis=1, keys=keys)
+    expected_values = [[1, 4, 1, 4], [2, 5, 2, 5], [3, 6, 3, 6]]
+    expected_columns = MultiIndex.from_tuples(
+        [(keys[0], "a"), (keys[0], "b"), (keys[1], "a"), (keys[1], "b")]
+    )
+    expected = DataFrame(expected_values, columns=expected_columns)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.filterwarnings(
+    "ignore:Passing a BlockManager|Passing a SingleBlockManager:DeprecationWarning"
+)
+@pytest.mark.parametrize(
+    "obj",
+    [
+        tm.SubclassedDataFrame({"A": np.arange(0, 10)}),
+        tm.SubclassedSeries(np.arange(0, 10), name="A"),
+    ],
+)
+def test_concat_preserves_subclass(obj):
+    # GH28330 -- preserve subclass
+
+    result = concat([obj, obj])
+    assert isinstance(result, type(obj))
+
+
+def test_concat_frame_axis0_extension_dtypes():
+    # preserve extension dtype (through common_dtype mechanism)
+    df1 = DataFrame({"a": pd.array([1, 2, 3], dtype="Int64")})
+    df2 = DataFrame({"a": np.array([4, 5, 6])})
+
+    result = concat([df1, df2], ignore_index=True)
+    expected = DataFrame({"a": [1, 2, 3, 4, 5, 6]}, dtype="Int64")
+    tm.assert_frame_equal(result, expected)
+
+    result = concat([df2, df1], ignore_index=True)
+    expected = DataFrame({"a": [4, 5, 6, 1, 2, 3]}, dtype="Int64")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_preserves_extension_int64_dtype():
+    # GH 24768
+    df_a = DataFrame({"a": [-1]}, dtype="Int64")
+    df_b = DataFrame({"b": [1]}, dtype="Int64")
+    result = concat([df_a, df_b], ignore_index=True)
+    expected = DataFrame({"a": [-1, None], "b": [None, 1]}, dtype="Int64")
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "dtype1,dtype2,expected_dtype",
+    [
+        ("bool", "bool", "bool"),
+        ("boolean", "bool", "boolean"),
+        ("bool", "boolean", "boolean"),
+        ("boolean", "boolean", "boolean"),
+    ],
+)
+def test_concat_bool_types(dtype1, dtype2, expected_dtype):
+    # GH 42800
+    ser1 = Series([True, False], dtype=dtype1)
+    ser2 = Series([False, True], dtype=dtype2)
+    result = concat([ser1, ser2], ignore_index=True)
+    expected = Series([True, False, False, True], dtype=expected_dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("keys", "integrity"),
+    [
+        (["red"] * 3, True),
+        (["red"] * 3, False),
+        (["red", "blue", "red"], False),
+        (["red", "blue", "red"], True),
+    ],
+)
+def test_concat_repeated_keys(keys, integrity):
+    # GH: 20816
+    series_list = [Series({"a": 1}), Series({"b": 2}), Series({"c": 3})]
+    result = concat(series_list, keys=keys, verify_integrity=integrity)
+    tuples = list(zip(keys, ["a", "b", "c"]))
+    expected = Series([1, 2, 3], index=MultiIndex.from_tuples(tuples))
+    tm.assert_series_equal(result, expected)
+
+
+def test_concat_null_object_with_dti():
+    # GH#40841
+    dti = pd.DatetimeIndex(
+        ["2021-04-08 21:21:14+00:00"], dtype="datetime64[ns, UTC]", name="Time (UTC)"
+    )
+    right = DataFrame(data={"C": [0.5274]}, index=dti)
+
+    idx = Index([None], dtype="object", name="Maybe Time (UTC)")
+    left = DataFrame(data={"A": [None], "B": [np.nan]}, index=idx)
+
+    result = concat([left, right], axis="columns")
+
+    exp_index = Index([None, dti[0]], dtype=object)
+    expected = DataFrame(
+        {
+            "A": np.array([None, np.nan], dtype=object),
+            "B": [np.nan, np.nan],
+            "C": [np.nan, 0.5274],
+        },
+        index=exp_index,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_multiindex_with_empty_rangeindex():
+    # GH#41234
+    mi = MultiIndex.from_tuples([("B", 1), ("C", 1)])
+    df1 = DataFrame([[1, 2]], columns=mi)
+    df2 = DataFrame(index=[1], columns=pd.RangeIndex(0))
+
+    result = concat([df1, df2])
+    expected = DataFrame([[1, 2], [np.nan, np.nan]], columns=mi)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        Series(data=[1, 2]),
+        DataFrame(
+            data={
+                "col1": [1, 2],
+            }
+        ),
+        DataFrame(dtype=float),
+        Series(dtype=float),
+    ],
+)
+def test_concat_drop_attrs(data):
+    # GH#41828
+    df1 = data.copy()
+    df1.attrs = {1: 1}
+    df2 = data.copy()
+    df2.attrs = {1: 2}
+    df = concat([df1, df2])
+    assert len(df.attrs) == 0
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        Series(data=[1, 2]),
+        DataFrame(
+            data={
+                "col1": [1, 2],
+            }
+        ),
+        DataFrame(dtype=float),
+        Series(dtype=float),
+    ],
+)
+def test_concat_retain_attrs(data):
+    # GH#41828
+    df1 = data.copy()
+    df1.attrs = {1: 1}
+    df2 = data.copy()
+    df2.attrs = {1: 1}
+    df = concat([df1, df2])
+    assert df.attrs[1] == 1
+
+
+@td.skip_array_manager_invalid_test
+@pytest.mark.parametrize("df_dtype", ["float64", "int64", "datetime64[ns]"])
+@pytest.mark.parametrize("empty_dtype", [None, "float64", "object"])
+def test_concat_ignore_empty_object_float(empty_dtype, df_dtype):
+    # https://github.com/pandas-dev/pandas/issues/45637
+    df = DataFrame({"foo": [1, 2], "bar": [1, 2]}, dtype=df_dtype)
+    empty = DataFrame(columns=["foo", "bar"], dtype=empty_dtype)
+
+    msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
+    warn = None
+    if df_dtype == "datetime64[ns]" or (
+        df_dtype == "float64" and empty_dtype != "float64"
+    ):
+        warn = FutureWarning
+    with tm.assert_produces_warning(warn, match=msg):
+        result = concat([empty, df])
+    expected = df
+    if df_dtype == "int64":
+        # TODO what exact behaviour do we want for integer eventually?
+        if empty_dtype == "float64":
+            expected = df.astype("float64")
+        else:
+            expected = df.astype("object")
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_array_manager_invalid_test
+@pytest.mark.parametrize("df_dtype", ["float64", "int64", "datetime64[ns]"])
+@pytest.mark.parametrize("empty_dtype", [None, "float64", "object"])
+def test_concat_ignore_all_na_object_float(empty_dtype, df_dtype):
+    df = DataFrame({"foo": [1, 2], "bar": [1, 2]}, dtype=df_dtype)
+    empty = DataFrame({"foo": [np.nan], "bar": [np.nan]}, dtype=empty_dtype)
+
+    if df_dtype == "int64":
+        # TODO what exact behaviour do we want for integer eventually?
+        if empty_dtype == "object":
+            df_dtype = "object"
+        else:
+            df_dtype = "float64"
+
+    msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
+    warn = None
+    if empty_dtype != df_dtype and empty_dtype is not None:
+        warn = FutureWarning
+    elif df_dtype == "datetime64[ns]":
+        warn = FutureWarning
+
+    with tm.assert_produces_warning(warn, match=msg):
+        result = concat([empty, df], ignore_index=True)
+
+    expected = DataFrame({"foo": [np.nan, 1, 2], "bar": [np.nan, 1, 2]}, dtype=df_dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+@td.skip_array_manager_invalid_test
+def test_concat_ignore_empty_from_reindex():
+    # https://github.com/pandas-dev/pandas/pull/43507#issuecomment-920375856
+    df1 = DataFrame({"a": [1], "b": [pd.Timestamp("2012-01-01")]})
+    df2 = DataFrame({"a": [2]})
+
+    aligned = df2.reindex(columns=df1.columns)
+
+    msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = concat([df1, aligned], ignore_index=True)
+    expected = df1 = DataFrame({"a": [1, 2], "b": [pd.Timestamp("2012-01-01"), pd.NaT]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_mismatched_keys_length():
+    # GH#43485
+    ser = Series(range(5))
+    sers = [ser + n for n in range(4)]
+    keys = ["A", "B", "C"]
+
+    msg = r"The behavior of pd.concat with len\(keys\) != len\(objs\) is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        concat(sers, keys=keys, axis=1)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        concat(sers, keys=keys, axis=0)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        concat((x for x in sers), keys=(y for y in keys), axis=1)
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        concat((x for x in sers), keys=(y for y in keys), axis=0)
+
+
+def test_concat_multiindex_with_category():
+    df1 = DataFrame(
+        {
+            "c1": Series(list("abc"), dtype="category"),
+            "c2": Series(list("eee"), dtype="category"),
+            "i2": Series([1, 2, 3]),
+        }
+    )
+    df1 = df1.set_index(["c1", "c2"])
+    df2 = DataFrame(
+        {
+            "c1": Series(list("abc"), dtype="category"),
+            "c2": Series(list("eee"), dtype="category"),
+            "i2": Series([4, 5, 6]),
+        }
+    )
+    df2 = df2.set_index(["c1", "c2"])
+    result = concat([df1, df2])
+    expected = DataFrame(
+        {
+            "c1": Series(list("abcabc"), dtype="category"),
+            "c2": Series(list("eeeeee"), dtype="category"),
+            "i2": Series([1, 2, 3, 4, 5, 6]),
+        }
+    )
+    expected = expected.set_index(["c1", "c2"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_ea_upcast():
+    # GH#54848
+    df1 = DataFrame(["a"], dtype="string")
+    df2 = DataFrame([1], dtype="Int64")
+    result = concat([df1, df2])
+    expected = DataFrame(["a", 1], index=[0, 0])
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_dataframe.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_dataframe.py
new file mode 100644
index 0000000000000000000000000000000000000000..105ffe84a07038983c1c61a5c01e14626bc9ed6e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_dataframe.py
@@ -0,0 +1,230 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    concat,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameConcat:
+    def test_concat_multiple_frames_dtypes(self):
+        # GH#2759
+        df1 = DataFrame(data=np.ones((10, 2)), columns=["foo", "bar"], dtype=np.float64)
+        df2 = DataFrame(data=np.ones((10, 2)), dtype=np.float32)
+        results = concat((df1, df2), axis=1).dtypes
+        expected = Series(
+            [np.dtype("float64")] * 2 + [np.dtype("float32")] * 2,
+            index=["foo", "bar", 0, 1],
+        )
+        tm.assert_series_equal(results, expected)
+
+    def test_concat_tuple_keys(self):
+        # GH#14438
+        df1 = DataFrame(np.ones((2, 2)), columns=list("AB"))
+        df2 = DataFrame(np.ones((3, 2)) * 2, columns=list("AB"))
+        results = concat((df1, df2), keys=[("bee", "bah"), ("bee", "boo")])
+        expected = DataFrame(
+            {
+                "A": {
+                    ("bee", "bah", 0): 1.0,
+                    ("bee", "bah", 1): 1.0,
+                    ("bee", "boo", 0): 2.0,
+                    ("bee", "boo", 1): 2.0,
+                    ("bee", "boo", 2): 2.0,
+                },
+                "B": {
+                    ("bee", "bah", 0): 1.0,
+                    ("bee", "bah", 1): 1.0,
+                    ("bee", "boo", 0): 2.0,
+                    ("bee", "boo", 1): 2.0,
+                    ("bee", "boo", 2): 2.0,
+                },
+            }
+        )
+        tm.assert_frame_equal(results, expected)
+
+    def test_concat_named_keys(self):
+        # GH#14252
+        df = DataFrame({"foo": [1, 2], "bar": [0.1, 0.2]})
+        index = Index(["a", "b"], name="baz")
+        concatted_named_from_keys = concat([df, df], keys=index)
+        expected_named = DataFrame(
+            {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]},
+            index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=["baz", None]),
+        )
+        tm.assert_frame_equal(concatted_named_from_keys, expected_named)
+
+        index_no_name = Index(["a", "b"], name=None)
+        concatted_named_from_names = concat([df, df], keys=index_no_name, names=["baz"])
+        tm.assert_frame_equal(concatted_named_from_names, expected_named)
+
+        concatted_unnamed = concat([df, df], keys=index_no_name)
+        expected_unnamed = DataFrame(
+            {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]},
+            index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=[None, None]),
+        )
+        tm.assert_frame_equal(concatted_unnamed, expected_unnamed)
+
+    def test_concat_axis_parameter(self):
+        # GH#14369
+        df1 = DataFrame({"A": [0.1, 0.2]}, index=range(2))
+        df2 = DataFrame({"A": [0.3, 0.4]}, index=range(2))
+
+        # Index/row/0 DataFrame
+        expected_index = DataFrame({"A": [0.1, 0.2, 0.3, 0.4]}, index=[0, 1, 0, 1])
+
+        concatted_index = concat([df1, df2], axis="index")
+        tm.assert_frame_equal(concatted_index, expected_index)
+
+        concatted_row = concat([df1, df2], axis="rows")
+        tm.assert_frame_equal(concatted_row, expected_index)
+
+        concatted_0 = concat([df1, df2], axis=0)
+        tm.assert_frame_equal(concatted_0, expected_index)
+
+        # Columns/1 DataFrame
+        expected_columns = DataFrame(
+            [[0.1, 0.3], [0.2, 0.4]], index=[0, 1], columns=["A", "A"]
+        )
+
+        concatted_columns = concat([df1, df2], axis="columns")
+        tm.assert_frame_equal(concatted_columns, expected_columns)
+
+        concatted_1 = concat([df1, df2], axis=1)
+        tm.assert_frame_equal(concatted_1, expected_columns)
+
+        series1 = Series([0.1, 0.2])
+        series2 = Series([0.3, 0.4])
+
+        # Index/row/0 Series
+        expected_index_series = Series([0.1, 0.2, 0.3, 0.4], index=[0, 1, 0, 1])
+
+        concatted_index_series = concat([series1, series2], axis="index")
+        tm.assert_series_equal(concatted_index_series, expected_index_series)
+
+        concatted_row_series = concat([series1, series2], axis="rows")
+        tm.assert_series_equal(concatted_row_series, expected_index_series)
+
+        concatted_0_series = concat([series1, series2], axis=0)
+        tm.assert_series_equal(concatted_0_series, expected_index_series)
+
+        # Columns/1 Series
+        expected_columns_series = DataFrame(
+            [[0.1, 0.3], [0.2, 0.4]], index=[0, 1], columns=[0, 1]
+        )
+
+        concatted_columns_series = concat([series1, series2], axis="columns")
+        tm.assert_frame_equal(concatted_columns_series, expected_columns_series)
+
+        concatted_1_series = concat([series1, series2], axis=1)
+        tm.assert_frame_equal(concatted_1_series, expected_columns_series)
+
+        # Testing ValueError
+        with pytest.raises(ValueError, match="No axis named"):
+            concat([series1, series2], axis="something")
+
+    def test_concat_numerical_names(self):
+        # GH#15262, GH#12223
+        df = DataFrame(
+            {"col": range(9)},
+            dtype="int32",
+            index=(
+                pd.MultiIndex.from_product(
+                    [["A0", "A1", "A2"], ["B0", "B1", "B2"]], names=[1, 2]
+                )
+            ),
+        )
+        result = concat((df.iloc[:2, :], df.iloc[-2:, :]))
+        expected = DataFrame(
+            {"col": [0, 1, 7, 8]},
+            dtype="int32",
+            index=pd.MultiIndex.from_tuples(
+                [("A0", "B0"), ("A0", "B1"), ("A2", "B1"), ("A2", "B2")], names=[1, 2]
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_astype_dup_col(self):
+        # GH#23049
+        df = DataFrame([{"a": "b"}])
+        df = concat([df, df], axis=1)
+
+        result = df.astype("category")
+        expected = DataFrame(
+            np.array(["b", "b"]).reshape(1, 2), columns=["a", "a"]
+        ).astype("category")
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_dataframe_keys_bug(self, sort):
+        t1 = DataFrame(
+            {"value": Series([1, 2, 3], index=Index(["a", "b", "c"], name="id"))}
+        )
+        t2 = DataFrame({"value": Series([7, 8], index=Index(["a", "b"], name="id"))})
+
+        # it works
+        result = concat([t1, t2], axis=1, keys=["t1", "t2"], sort=sort)
+        assert list(result.columns) == [("t1", "value"), ("t2", "value")]
+
+    def test_concat_bool_with_int(self):
+        # GH#42092 we may want to change this to return object, but that
+        #  would need a deprecation
+        df1 = DataFrame(Series([True, False, True, True], dtype="bool"))
+        df2 = DataFrame(Series([1, 0, 1], dtype="int64"))
+
+        result = concat([df1, df2])
+        expected = concat([df1.astype("int64"), df2])
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_duplicates_in_index_with_keys(self):
+        # GH#42651
+        index = [1, 1, 3]
+        data = [1, 2, 3]
+
+        df = DataFrame(data=data, index=index)
+        result = concat([df], keys=["A"], names=["ID", "date"])
+        mi = pd.MultiIndex.from_product([["A"], index], names=["ID", "date"])
+        expected = DataFrame(data=data, index=mi)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_index_equal(result.index.levels[1], Index([1, 3], name="date"))
+
+    @pytest.mark.parametrize("ignore_index", [True, False])
+    @pytest.mark.parametrize("order", ["C", "F"])
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_concat_copies(self, axis, order, ignore_index, using_copy_on_write):
+        # based on asv ConcatDataFrames
+        df = DataFrame(np.zeros((10000, 200), dtype=np.float32, order=order))
+
+        res = concat([df] * 5, axis=axis, ignore_index=ignore_index, copy=True)
+
+        if not using_copy_on_write:
+            for arr in res._iter_column_arrays():
+                for arr2 in df._iter_column_arrays():
+                    assert not np.shares_memory(arr, arr2)
+
+    def test_outer_sort_columns(self):
+        # GH#47127
+        df1 = DataFrame({"A": [0], "B": [1], 0: 1})
+        df2 = DataFrame({"A": [100]})
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame({0: [1.0, np.nan], "A": [0, 100], "B": [1.0, np.nan]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_inner_sort_columns(self):
+        # GH#47127
+        df1 = DataFrame({"A": [0], "B": [1], 0: 1})
+        df2 = DataFrame({"A": [100], 0: 2})
+        result = concat([df1, df2], ignore_index=True, join="inner", sort=True)
+        expected = DataFrame({0: [1, 2], "A": [0, 100]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_sort_columns_one_df(self):
+        # GH#47127
+        df1 = DataFrame({"A": [100], 0: 2})
+        result = concat([df1], ignore_index=True, join="inner", sort=True)
+        expected = DataFrame({0: [2], "A": [100]})
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_datetimes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_datetimes.py
new file mode 100644
index 0000000000000000000000000000000000000000..a06fc5eede55c25e3e75da00a0efb6e5cd0a78ce
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_datetimes.py
@@ -0,0 +1,590 @@
+import datetime as dt
+from datetime import datetime
+
+import dateutil
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+    to_timedelta,
+)
+import pandas._testing as tm
+
+
+class TestDatetimeConcat:
+    def test_concat_datetime64_block(self):
+        rng = date_range("1/1/2000", periods=10)
+
+        df = DataFrame({"time": rng})
+
+        result = concat([df, df])
+        assert (result.iloc[:10]["time"] == rng).all()
+        assert (result.iloc[10:]["time"] == rng).all()
+
+    def test_concat_datetime_datetime64_frame(self):
+        # GH#2624
+        rows = []
+        rows.append([datetime(2010, 1, 1), 1])
+        rows.append([datetime(2010, 1, 2), "hi"])
+
+        df2_obj = DataFrame.from_records(rows, columns=["date", "test"])
+
+        ind = date_range(start="2000/1/1", freq="D", periods=10)
+        df1 = DataFrame({"date": ind, "test": range(10)})
+
+        # it works!
+        concat([df1, df2_obj])
+
+    def test_concat_datetime_timezone(self):
+        # GH 18523
+        idx1 = date_range("2011-01-01", periods=3, freq="H", tz="Europe/Paris")
+        idx2 = date_range(start=idx1[0], end=idx1[-1], freq="H")
+        df1 = DataFrame({"a": [1, 2, 3]}, index=idx1)
+        df2 = DataFrame({"b": [1, 2, 3]}, index=idx2)
+        result = concat([df1, df2], axis=1)
+
+        exp_idx = (
+            DatetimeIndex(
+                [
+                    "2011-01-01 00:00:00+01:00",
+                    "2011-01-01 01:00:00+01:00",
+                    "2011-01-01 02:00:00+01:00",
+                ],
+                freq="H",
+            )
+            .tz_convert("UTC")
+            .tz_convert("Europe/Paris")
+        )
+
+        expected = DataFrame(
+            [[1, 1], [2, 2], [3, 3]], index=exp_idx, columns=["a", "b"]
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        idx3 = date_range("2011-01-01", periods=3, freq="H", tz="Asia/Tokyo")
+        df3 = DataFrame({"b": [1, 2, 3]}, index=idx3)
+        result = concat([df1, df3], axis=1)
+
+        exp_idx = DatetimeIndex(
+            [
+                "2010-12-31 15:00:00+00:00",
+                "2010-12-31 16:00:00+00:00",
+                "2010-12-31 17:00:00+00:00",
+                "2010-12-31 23:00:00+00:00",
+                "2011-01-01 00:00:00+00:00",
+                "2011-01-01 01:00:00+00:00",
+            ]
+        )
+
+        expected = DataFrame(
+            [
+                [np.nan, 1],
+                [np.nan, 2],
+                [np.nan, 3],
+                [1, np.nan],
+                [2, np.nan],
+                [3, np.nan],
+            ],
+            index=exp_idx,
+            columns=["a", "b"],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        # GH 13783: Concat after resample
+        result = concat([df1.resample("H").mean(), df2.resample("H").mean()], sort=True)
+        expected = DataFrame(
+            {"a": [1, 2, 3] + [np.nan] * 3, "b": [np.nan] * 3 + [1, 2, 3]},
+            index=idx1.append(idx1),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_datetimeindex_freq(self):
+        # GH 3232
+        # Monotonic index result
+        dr = date_range("01-Jan-2013", periods=100, freq="50L", tz="UTC")
+        data = list(range(100))
+        expected = DataFrame(data, index=dr)
+        result = concat([expected[:50], expected[50:]])
+        tm.assert_frame_equal(result, expected)
+
+        # Non-monotonic index result
+        result = concat([expected[50:], expected[:50]])
+        expected = DataFrame(data[50:] + data[:50], index=dr[50:].append(dr[:50]))
+        expected.index._data.freq = None
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_multiindex_datetime_object_index(self):
+        # https://github.com/pandas-dev/pandas/issues/11058
+        idx = Index(
+            [dt.date(2013, 1, 1), dt.date(2014, 1, 1), dt.date(2015, 1, 1)],
+            dtype="object",
+        )
+
+        s = Series(
+            ["a", "b"],
+            index=MultiIndex.from_arrays(
+                [
+                    [1, 2],
+                    idx[:-1],
+                ],
+                names=["first", "second"],
+            ),
+        )
+        s2 = Series(
+            ["a", "b"],
+            index=MultiIndex.from_arrays(
+                [[1, 2], idx[::2]],
+                names=["first", "second"],
+            ),
+        )
+        mi = MultiIndex.from_arrays(
+            [[1, 2, 2], idx],
+            names=["first", "second"],
+        )
+        assert mi.levels[1].dtype == object
+
+        expected = DataFrame(
+            [["a", "a"], ["b", np.nan], [np.nan, "b"]],
+            index=mi,
+        )
+        result = concat([s, s2], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_NaT_series(self):
+        # GH 11693
+        # test for merging NaT series with datetime series.
+        x = Series(
+            date_range("20151124 08:00", "20151124 09:00", freq="1h", tz="US/Eastern")
+        )
+        y = Series(pd.NaT, index=[0, 1], dtype="datetime64[ns, US/Eastern]")
+        expected = Series([x[0], x[1], pd.NaT, pd.NaT])
+
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+        # all NaT with tz
+        expected = Series(pd.NaT, index=range(4), dtype="datetime64[ns, US/Eastern]")
+        result = concat([y, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+        # without tz
+        x = Series(date_range("20151124 08:00", "20151124 09:00", freq="1h"))
+        y = Series(date_range("20151124 10:00", "20151124 11:00", freq="1h"))
+        y[:] = pd.NaT
+        expected = Series([x[0], x[1], pd.NaT, pd.NaT])
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+        # all NaT without tz
+        x[:] = pd.NaT
+        expected = Series(pd.NaT, index=range(4), dtype="datetime64[ns]")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_concat_NaT_dataframes(self, tz):
+        # GH 12396
+
+        first = DataFrame([[pd.NaT], [pd.NaT]])
+        first = first.apply(lambda x: x.dt.tz_localize(tz))
+        second = DataFrame(
+            [[Timestamp("2015/01/01", tz=tz)], [Timestamp("2016/01/01", tz=tz)]],
+            index=[2, 3],
+        )
+        expected = DataFrame(
+            [
+                pd.NaT,
+                pd.NaT,
+                Timestamp("2015/01/01", tz=tz),
+                Timestamp("2016/01/01", tz=tz),
+            ]
+        )
+
+        result = concat([first, second], axis=0)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz1", [None, "UTC"])
+    @pytest.mark.parametrize("tz2", [None, "UTC"])
+    @pytest.mark.parametrize("item", [pd.NaT, Timestamp("20150101")])
+    def test_concat_NaT_dataframes_all_NaT_axis_0(
+        self, tz1, tz2, item, using_array_manager
+    ):
+        # GH 12396
+
+        # tz-naive
+        first = DataFrame([[pd.NaT], [pd.NaT]]).apply(lambda x: x.dt.tz_localize(tz1))
+        second = DataFrame([item]).apply(lambda x: x.dt.tz_localize(tz2))
+
+        result = concat([first, second], axis=0)
+        expected = DataFrame(Series([pd.NaT, pd.NaT, item], index=[0, 1, 0]))
+        expected = expected.apply(lambda x: x.dt.tz_localize(tz2))
+        if tz1 != tz2:
+            expected = expected.astype(object)
+            if item is pd.NaT and not using_array_manager:
+                # GH#18463
+                # TODO: setting nan here is to keep the test passing as we
+                #  make assert_frame_equal stricter, but is nan really the
+                #  ideal behavior here?
+                if tz1 is not None:
+                    expected.iloc[-1, 0] = np.nan
+                else:
+                    expected.iloc[:-1, 0] = np.nan
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz1", [None, "UTC"])
+    @pytest.mark.parametrize("tz2", [None, "UTC"])
+    def test_concat_NaT_dataframes_all_NaT_axis_1(self, tz1, tz2):
+        # GH 12396
+
+        first = DataFrame(Series([pd.NaT, pd.NaT]).dt.tz_localize(tz1))
+        second = DataFrame(Series([pd.NaT]).dt.tz_localize(tz2), columns=[1])
+        expected = DataFrame(
+            {
+                0: Series([pd.NaT, pd.NaT]).dt.tz_localize(tz1),
+                1: Series([pd.NaT, pd.NaT]).dt.tz_localize(tz2),
+            }
+        )
+        result = concat([first, second], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz1", [None, "UTC"])
+    @pytest.mark.parametrize("tz2", [None, "UTC"])
+    def test_concat_NaT_series_dataframe_all_NaT(self, tz1, tz2):
+        # GH 12396
+
+        # tz-naive
+        first = Series([pd.NaT, pd.NaT]).dt.tz_localize(tz1)
+        second = DataFrame(
+            [
+                [Timestamp("2015/01/01", tz=tz2)],
+                [Timestamp("2016/01/01", tz=tz2)],
+            ],
+            index=[2, 3],
+        )
+
+        expected = DataFrame(
+            [
+                pd.NaT,
+                pd.NaT,
+                Timestamp("2015/01/01", tz=tz2),
+                Timestamp("2016/01/01", tz=tz2),
+            ]
+        )
+        if tz1 != tz2:
+            expected = expected.astype(object)
+
+        result = concat([first, second])
+        tm.assert_frame_equal(result, expected)
+
+
+class TestTimezoneConcat:
+    def test_concat_tz_series(self):
+        # gh-11755: tz and no tz
+        x = Series(date_range("20151124 08:00", "20151124 09:00", freq="1h", tz="UTC"))
+        y = Series(date_range("2012-01-01", "2012-01-02"))
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="object")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+        # gh-11887: concat tz and object
+        x = Series(date_range("20151124 08:00", "20151124 09:00", freq="1h", tz="UTC"))
+        y = Series(["a", "b"])
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="object")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+        # see gh-12217 and gh-12306
+        # Concatenating two UTC times
+        first = DataFrame([[datetime(2016, 1, 1)]])
+        first[0] = first[0].dt.tz_localize("UTC")
+
+        second = DataFrame([[datetime(2016, 1, 2)]])
+        second[0] = second[0].dt.tz_localize("UTC")
+
+        result = concat([first, second])
+        assert result[0].dtype == "datetime64[ns, UTC]"
+
+        # Concatenating two London times
+        first = DataFrame([[datetime(2016, 1, 1)]])
+        first[0] = first[0].dt.tz_localize("Europe/London")
+
+        second = DataFrame([[datetime(2016, 1, 2)]])
+        second[0] = second[0].dt.tz_localize("Europe/London")
+
+        result = concat([first, second])
+        assert result[0].dtype == "datetime64[ns, Europe/London]"
+
+        # Concatenating 2+1 London times
+        first = DataFrame([[datetime(2016, 1, 1)], [datetime(2016, 1, 2)]])
+        first[0] = first[0].dt.tz_localize("Europe/London")
+
+        second = DataFrame([[datetime(2016, 1, 3)]])
+        second[0] = second[0].dt.tz_localize("Europe/London")
+
+        result = concat([first, second])
+        assert result[0].dtype == "datetime64[ns, Europe/London]"
+
+        # Concat'ing 1+2 London times
+        first = DataFrame([[datetime(2016, 1, 1)]])
+        first[0] = first[0].dt.tz_localize("Europe/London")
+
+        second = DataFrame([[datetime(2016, 1, 2)], [datetime(2016, 1, 3)]])
+        second[0] = second[0].dt.tz_localize("Europe/London")
+
+        result = concat([first, second])
+        assert result[0].dtype == "datetime64[ns, Europe/London]"
+
+    def test_concat_tz_series_tzlocal(self):
+        # see gh-13583
+        x = [
+            Timestamp("2011-01-01", tz=dateutil.tz.tzlocal()),
+            Timestamp("2011-02-01", tz=dateutil.tz.tzlocal()),
+        ]
+        y = [
+            Timestamp("2012-01-01", tz=dateutil.tz.tzlocal()),
+            Timestamp("2012-02-01", tz=dateutil.tz.tzlocal()),
+        ]
+
+        result = concat([Series(x), Series(y)], ignore_index=True)
+        tm.assert_series_equal(result, Series(x + y))
+        assert result.dtype == "datetime64[ns, tzlocal()]"
+
+    def test_concat_tz_series_with_datetimelike(self):
+        # see gh-12620: tz and timedelta
+        x = [
+            Timestamp("2011-01-01", tz="US/Eastern"),
+            Timestamp("2011-02-01", tz="US/Eastern"),
+        ]
+        y = [pd.Timedelta("1 day"), pd.Timedelta("2 day")]
+        result = concat([Series(x), Series(y)], ignore_index=True)
+        tm.assert_series_equal(result, Series(x + y, dtype="object"))
+
+        # tz and period
+        y = [pd.Period("2011-03", freq="M"), pd.Period("2011-04", freq="M")]
+        result = concat([Series(x), Series(y)], ignore_index=True)
+        tm.assert_series_equal(result, Series(x + y, dtype="object"))
+
+    def test_concat_tz_frame(self):
+        df2 = DataFrame(
+            {
+                "A": Timestamp("20130102", tz="US/Eastern"),
+                "B": Timestamp("20130603", tz="CET"),
+            },
+            index=range(5),
+        )
+
+        # concat
+        df3 = concat([df2.A.to_frame(), df2.B.to_frame()], axis=1)
+        tm.assert_frame_equal(df2, df3)
+
+    def test_concat_multiple_tzs(self):
+        # GH#12467
+        # combining datetime tz-aware and naive DataFrames
+        ts1 = Timestamp("2015-01-01", tz=None)
+        ts2 = Timestamp("2015-01-01", tz="UTC")
+        ts3 = Timestamp("2015-01-01", tz="EST")
+
+        df1 = DataFrame({"time": [ts1]})
+        df2 = DataFrame({"time": [ts2]})
+        df3 = DataFrame({"time": [ts3]})
+
+        results = concat([df1, df2]).reset_index(drop=True)
+        expected = DataFrame({"time": [ts1, ts2]}, dtype=object)
+        tm.assert_frame_equal(results, expected)
+
+        results = concat([df1, df3]).reset_index(drop=True)
+        expected = DataFrame({"time": [ts1, ts3]}, dtype=object)
+        tm.assert_frame_equal(results, expected)
+
+        results = concat([df2, df3]).reset_index(drop=True)
+        expected = DataFrame({"time": [ts2, ts3]})
+        tm.assert_frame_equal(results, expected)
+
+    def test_concat_multiindex_with_tz(self):
+        # GH 6606
+        df = DataFrame(
+            {
+                "dt": [
+                    datetime(2014, 1, 1),
+                    datetime(2014, 1, 2),
+                    datetime(2014, 1, 3),
+                ],
+                "b": ["A", "B", "C"],
+                "c": [1, 2, 3],
+                "d": [4, 5, 6],
+            }
+        )
+        df["dt"] = df["dt"].apply(lambda d: Timestamp(d, tz="US/Pacific"))
+        df = df.set_index(["dt", "b"])
+
+        exp_idx1 = DatetimeIndex(
+            ["2014-01-01", "2014-01-02", "2014-01-03"] * 2, tz="US/Pacific", name="dt"
+        )
+        exp_idx2 = Index(["A", "B", "C"] * 2, name="b")
+        exp_idx = MultiIndex.from_arrays([exp_idx1, exp_idx2])
+        expected = DataFrame(
+            {"c": [1, 2, 3] * 2, "d": [4, 5, 6] * 2}, index=exp_idx, columns=["c", "d"]
+        )
+
+        result = concat([df, df])
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_tz_not_aligned(self):
+        # GH#22796
+        ts = pd.to_datetime([1, 2]).tz_localize("UTC")
+        a = DataFrame({"A": ts})
+        b = DataFrame({"A": ts, "B": ts})
+        result = concat([a, b], sort=True, ignore_index=True)
+        expected = DataFrame(
+            {"A": list(ts) + list(ts), "B": [pd.NaT, pd.NaT] + list(ts)}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "t1",
+        [
+            "2015-01-01",
+            pytest.param(
+                pd.NaT,
+                marks=pytest.mark.xfail(
+                    reason="GH23037 incorrect dtype when concatenating"
+                ),
+            ),
+        ],
+    )
+    def test_concat_tz_NaT(self, t1):
+        # GH#22796
+        # Concatenating tz-aware multicolumn DataFrames
+        ts1 = Timestamp(t1, tz="UTC")
+        ts2 = Timestamp("2015-01-01", tz="UTC")
+        ts3 = Timestamp("2015-01-01", tz="UTC")
+
+        df1 = DataFrame([[ts1, ts2]])
+        df2 = DataFrame([[ts3]])
+
+        result = concat([df1, df2])
+        expected = DataFrame([[ts1, ts2], [ts3, pd.NaT]], index=[0, 0])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_tz_with_empty(self):
+        # GH 9188
+        result = concat(
+            [DataFrame(date_range("2000", periods=1, tz="UTC")), DataFrame()]
+        )
+        expected = DataFrame(date_range("2000", periods=1, tz="UTC"))
+        tm.assert_frame_equal(result, expected)
+
+
+class TestPeriodConcat:
+    def test_concat_period_series(self):
+        x = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="D"))
+        y = Series(pd.PeriodIndex(["2015-10-01", "2016-01-01"], freq="D"))
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="Period[D]")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_period_multiple_freq_series(self):
+        x = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="D"))
+        y = Series(pd.PeriodIndex(["2015-10-01", "2016-01-01"], freq="M"))
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="object")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+        assert result.dtype == "object"
+
+    def test_concat_period_other_series(self):
+        x = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="D"))
+        y = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="M"))
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="object")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+        assert result.dtype == "object"
+
+        # non-period
+        x = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="D"))
+        y = Series(DatetimeIndex(["2015-11-01", "2015-12-01"]))
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="object")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+        assert result.dtype == "object"
+
+        x = Series(pd.PeriodIndex(["2015-11-01", "2015-12-01"], freq="D"))
+        y = Series(["A", "B"])
+        expected = Series([x[0], x[1], y[0], y[1]], dtype="object")
+        result = concat([x, y], ignore_index=True)
+        tm.assert_series_equal(result, expected)
+        assert result.dtype == "object"
+
+
+def test_concat_timedelta64_block():
+    rng = to_timedelta(np.arange(10), unit="s")
+
+    df = DataFrame({"time": rng})
+
+    result = concat([df, df])
+    tm.assert_frame_equal(result.iloc[:10], df)
+    tm.assert_frame_equal(result.iloc[10:], df)
+
+
+def test_concat_multiindex_datetime_nat():
+    # GH#44900
+    left = DataFrame({"a": 1}, index=MultiIndex.from_tuples([(1, pd.NaT)]))
+    right = DataFrame(
+        {"b": 2}, index=MultiIndex.from_tuples([(1, pd.NaT), (2, pd.NaT)])
+    )
+    result = concat([left, right], axis="columns")
+    expected = DataFrame(
+        {"a": [1.0, np.nan], "b": 2}, MultiIndex.from_tuples([(1, pd.NaT), (2, pd.NaT)])
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_float_datetime64(using_array_manager):
+    # GH#32934
+    df_time = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")})
+    df_float = DataFrame({"A": pd.array([1.0], dtype="float64")})
+
+    expected = DataFrame(
+        {
+            "A": [
+                pd.array(["2000"], dtype="datetime64[ns]")[0],
+                pd.array([1.0], dtype="float64")[0],
+            ]
+        },
+        index=[0, 0],
+    )
+    result = concat([df_time, df_float])
+    tm.assert_frame_equal(result, expected)
+
+    expected = DataFrame({"A": pd.array([], dtype="object")})
+    result = concat([df_time.iloc[:0], df_float.iloc[:0]])
+    tm.assert_frame_equal(result, expected)
+
+    expected = DataFrame({"A": pd.array([1.0], dtype="object")})
+    result = concat([df_time.iloc[:0], df_float])
+    tm.assert_frame_equal(result, expected)
+
+    if not using_array_manager:
+        expected = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")})
+        msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = concat([df_time, df_float.iloc[:0]])
+        tm.assert_frame_equal(result, expected)
+    else:
+        expected = DataFrame({"A": pd.array(["2000"], dtype="datetime64[ns]")}).astype(
+            {"A": "object"}
+        )
+        result = concat([df_time, df_float.iloc[:0]])
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_empty.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_empty.py
new file mode 100644
index 0000000000000000000000000000000000000000..c80f3244dccaf89f35bb92cc5ebd32471a1aeefc
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_empty.py
@@ -0,0 +1,293 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    RangeIndex,
+    Series,
+    concat,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestEmptyConcat:
+    def test_handle_empty_objects(self, sort):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)), columns=list("abcd")
+        )
+
+        dfcopy = df[:5].copy()
+        dfcopy["foo"] = "bar"
+        empty = df[5:5]
+
+        frames = [dfcopy, empty, empty, df[5:]]
+        concatted = concat(frames, axis=0, sort=sort)
+
+        expected = df.reindex(columns=["a", "b", "c", "d", "foo"])
+        expected["foo"] = expected["foo"].astype("O")
+        expected.loc[0:4, "foo"] = "bar"
+
+        tm.assert_frame_equal(concatted, expected)
+
+        # empty as first element with time series
+        # GH3259
+        df = DataFrame(
+            {"A": range(10000)}, index=date_range("20130101", periods=10000, freq="s")
+        )
+        empty = DataFrame()
+        result = concat([df, empty], axis=1)
+        tm.assert_frame_equal(result, df)
+        result = concat([empty, df], axis=1)
+        tm.assert_frame_equal(result, df)
+
+        result = concat([df, empty])
+        tm.assert_frame_equal(result, df)
+        result = concat([empty, df])
+        tm.assert_frame_equal(result, df)
+
+    def test_concat_empty_series(self):
+        # GH 11082
+        s1 = Series([1, 2, 3], name="x")
+        s2 = Series(name="y", dtype="float64")
+        res = concat([s1, s2], axis=1)
+        exp = DataFrame(
+            {"x": [1, 2, 3], "y": [np.nan, np.nan, np.nan]},
+            index=RangeIndex(3),
+        )
+        tm.assert_frame_equal(res, exp)
+
+        s1 = Series([1, 2, 3], name="x")
+        s2 = Series(name="y", dtype="float64")
+        msg = "The behavior of array concatenation with empty entries is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = concat([s1, s2], axis=0)
+        # name will be reset
+        exp = Series([1, 2, 3])
+        tm.assert_series_equal(res, exp)
+
+        # empty Series with no name
+        s1 = Series([1, 2, 3], name="x")
+        s2 = Series(name=None, dtype="float64")
+        res = concat([s1, s2], axis=1)
+        exp = DataFrame(
+            {"x": [1, 2, 3], 0: [np.nan, np.nan, np.nan]},
+            columns=["x", 0],
+            index=RangeIndex(3),
+        )
+        tm.assert_frame_equal(res, exp)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    @pytest.mark.parametrize("values", [[], [1, 2, 3]])
+    def test_concat_empty_series_timelike(self, tz, values):
+        # GH 18447
+
+        first = Series([], dtype="M8[ns]").dt.tz_localize(tz)
+        dtype = None if values else np.float64
+        second = Series(values, dtype=dtype)
+
+        expected = DataFrame(
+            {
+                0: Series([pd.NaT] * len(values), dtype="M8[ns]").dt.tz_localize(tz),
+                1: values,
+            }
+        )
+        result = concat([first, second], axis=1)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "left,right,expected",
+        [
+            # booleans
+            (np.bool_, np.int32, np.object_),  # changed from int32 in 2.0 GH#39817
+            (np.bool_, np.float32, np.object_),
+            # datetime-like
+            ("m8[ns]", np.bool_, np.object_),
+            ("m8[ns]", np.int64, np.object_),
+            ("M8[ns]", np.bool_, np.object_),
+            ("M8[ns]", np.int64, np.object_),
+            # categorical
+            ("category", "category", "category"),
+            ("category", "object", "object"),
+        ],
+    )
+    def test_concat_empty_series_dtypes(self, left, right, expected):
+        # GH#39817, GH#45101
+        result = concat([Series(dtype=left), Series(dtype=right)])
+        assert result.dtype == expected
+
+    @pytest.mark.parametrize(
+        "dtype", ["float64", "int8", "uint8", "bool", "m8[ns]", "M8[ns]"]
+    )
+    def test_concat_empty_series_dtypes_match_roundtrips(self, dtype):
+        dtype = np.dtype(dtype)
+
+        result = concat([Series(dtype=dtype)])
+        assert result.dtype == dtype
+
+        result = concat([Series(dtype=dtype), Series(dtype=dtype)])
+        assert result.dtype == dtype
+
+    @pytest.mark.parametrize("dtype", ["float64", "int8", "uint8", "m8[ns]", "M8[ns]"])
+    @pytest.mark.parametrize(
+        "dtype2",
+        ["float64", "int8", "uint8", "m8[ns]", "M8[ns]"],
+    )
+    def test_concat_empty_series_dtypes_roundtrips(self, dtype, dtype2):
+        # round-tripping with self & like self
+        if dtype == dtype2:
+            pytest.skip("same dtype is not applicable for test")
+
+        def int_result_type(dtype, dtype2):
+            typs = {dtype.kind, dtype2.kind}
+            if not len(typs - {"i", "u", "b"}) and (
+                dtype.kind == "i" or dtype2.kind == "i"
+            ):
+                return "i"
+            elif not len(typs - {"u", "b"}) and (
+                dtype.kind == "u" or dtype2.kind == "u"
+            ):
+                return "u"
+            return None
+
+        def float_result_type(dtype, dtype2):
+            typs = {dtype.kind, dtype2.kind}
+            if not len(typs - {"f", "i", "u"}) and (
+                dtype.kind == "f" or dtype2.kind == "f"
+            ):
+                return "f"
+            return None
+
+        def get_result_type(dtype, dtype2):
+            result = float_result_type(dtype, dtype2)
+            if result is not None:
+                return result
+            result = int_result_type(dtype, dtype2)
+            if result is not None:
+                return result
+            return "O"
+
+        dtype = np.dtype(dtype)
+        dtype2 = np.dtype(dtype2)
+        expected = get_result_type(dtype, dtype2)
+        result = concat([Series(dtype=dtype), Series(dtype=dtype2)]).dtype
+        assert result.kind == expected
+
+    def test_concat_empty_series_dtypes_triple(self):
+        assert (
+            concat(
+                [Series(dtype="M8[ns]"), Series(dtype=np.bool_), Series(dtype=np.int64)]
+            ).dtype
+            == np.object_
+        )
+
+    def test_concat_empty_series_dtype_category_with_array(self):
+        # GH#18515
+        assert (
+            concat(
+                [Series(np.array([]), dtype="category"), Series(dtype="float64")]
+            ).dtype
+            == "float64"
+        )
+
+    def test_concat_empty_series_dtypes_sparse(self):
+        result = concat(
+            [
+                Series(dtype="float64").astype("Sparse"),
+                Series(dtype="float64").astype("Sparse"),
+            ]
+        )
+        assert result.dtype == "Sparse[float64]"
+
+        result = concat(
+            [Series(dtype="float64").astype("Sparse"), Series(dtype="float64")]
+        )
+        expected = pd.SparseDtype(np.float64)
+        assert result.dtype == expected
+
+        result = concat(
+            [Series(dtype="float64").astype("Sparse"), Series(dtype="object")]
+        )
+        expected = pd.SparseDtype("object")
+        assert result.dtype == expected
+
+    def test_concat_empty_df_object_dtype(self):
+        # GH 9149
+        df_1 = DataFrame({"Row": [0, 1, 1], "EmptyCol": np.nan, "NumberCol": [1, 2, 3]})
+        df_2 = DataFrame(columns=df_1.columns)
+        result = concat([df_1, df_2], axis=0)
+        expected = df_1.astype(object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_empty_dataframe_dtypes(self):
+        df = DataFrame(columns=list("abc"))
+        df["a"] = df["a"].astype(np.bool_)
+        df["b"] = df["b"].astype(np.int32)
+        df["c"] = df["c"].astype(np.float64)
+
+        result = concat([df, df])
+        assert result["a"].dtype == np.bool_
+        assert result["b"].dtype == np.int32
+        assert result["c"].dtype == np.float64
+
+        result = concat([df, df.astype(np.float64)])
+        assert result["a"].dtype == np.object_
+        assert result["b"].dtype == np.float64
+        assert result["c"].dtype == np.float64
+
+    def test_concat_inner_join_empty(self):
+        # GH 15328
+        df_empty = DataFrame()
+        df_a = DataFrame({"a": [1, 2]}, index=[0, 1], dtype="int64")
+        df_expected = DataFrame({"a": []}, index=RangeIndex(0), dtype="int64")
+
+        result = concat([df_a, df_empty], axis=1, join="inner")
+        tm.assert_frame_equal(result, df_expected)
+
+        result = concat([df_a, df_empty], axis=1, join="outer")
+        tm.assert_frame_equal(result, df_a)
+
+    def test_empty_dtype_coerce(self):
+        # xref to #12411
+        # xref to #12045
+        # xref to #11594
+        # see below
+
+        # 10571
+        df1 = DataFrame(data=[[1, None], [2, None]], columns=["a", "b"])
+        df2 = DataFrame(data=[[3, None], [4, None]], columns=["a", "b"])
+        result = concat([df1, df2])
+        expected = df1.dtypes
+        tm.assert_series_equal(result.dtypes, expected)
+
+    def test_concat_empty_dataframe(self):
+        # 39037
+        df1 = DataFrame(columns=["a", "b"])
+        df2 = DataFrame(columns=["b", "c"])
+        result = concat([df1, df2, df1])
+        expected = DataFrame(columns=["a", "b", "c"])
+        tm.assert_frame_equal(result, expected)
+
+        df3 = DataFrame(columns=["a", "b"])
+        df4 = DataFrame(columns=["b"])
+        result = concat([df3, df4])
+        expected = DataFrame(columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_empty_dataframe_different_dtypes(self):
+        # 39037
+        df1 = DataFrame({"a": [1, 2, 3], "b": ["a", "b", "c"]})
+        df2 = DataFrame({"a": [1, 2, 3]})
+
+        result = concat([df1[:0], df2[:0]])
+        assert result["a"].dtype == np.int64
+        assert result["b"].dtype == np.object_
+
+    def test_concat_to_empty_ea(self):
+        """48510 `concat` to an empty EA should maintain type EA dtype."""
+        df_empty = DataFrame({"a": pd.array([], dtype=pd.Int64Dtype())})
+        df_new = DataFrame({"a": pd.array([1, 2, 3], dtype=pd.Int64Dtype())})
+        expected = df_new.copy()
+        result = concat([df_empty, df_new])
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..f835bb953ce6c5a127749dff5c4315634403a858
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_index.py
@@ -0,0 +1,470 @@
+from copy import deepcopy
+
+import numpy as np
+import pytest
+
+from pandas.errors import PerformanceWarning
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    concat,
+)
+import pandas._testing as tm
+
+
+class TestIndexConcat:
+    def test_concat_ignore_index(self, sort):
+        frame1 = DataFrame(
+            {"test1": ["a", "b", "c"], "test2": [1, 2, 3], "test3": [4.5, 3.2, 1.2]}
+        )
+        frame2 = DataFrame({"test3": [5.2, 2.2, 4.3]})
+        frame1.index = Index(["x", "y", "z"])
+        frame2.index = Index(["x", "y", "q"])
+
+        v1 = concat([frame1, frame2], axis=1, ignore_index=True, sort=sort)
+
+        nan = np.nan
+        expected = DataFrame(
+            [
+                [nan, nan, nan, 4.3],
+                ["a", 1, 4.5, 5.2],
+                ["b", 2, 3.2, 2.2],
+                ["c", 3, 1.2, nan],
+            ],
+            index=Index(["q", "x", "y", "z"]),
+        )
+        if not sort:
+            expected = expected.loc[["x", "y", "z", "q"]]
+
+        tm.assert_frame_equal(v1, expected)
+
+    @pytest.mark.parametrize(
+        "name_in1,name_in2,name_in3,name_out",
+        [
+            ("idx", "idx", "idx", "idx"),
+            ("idx", "idx", None, None),
+            ("idx", None, None, None),
+            ("idx1", "idx2", None, None),
+            ("idx1", "idx1", "idx2", None),
+            ("idx1", "idx2", "idx3", None),
+            (None, None, None, None),
+        ],
+    )
+    def test_concat_same_index_names(self, name_in1, name_in2, name_in3, name_out):
+        # GH13475
+        indices = [
+            Index(["a", "b", "c"], name=name_in1),
+            Index(["b", "c", "d"], name=name_in2),
+            Index(["c", "d", "e"], name=name_in3),
+        ]
+        frames = [
+            DataFrame({c: [0, 1, 2]}, index=i) for i, c in zip(indices, ["x", "y", "z"])
+        ]
+        result = concat(frames, axis=1)
+
+        exp_ind = Index(["a", "b", "c", "d", "e"], name=name_out)
+        expected = DataFrame(
+            {
+                "x": [0, 1, 2, np.nan, np.nan],
+                "y": [np.nan, 0, 1, 2, np.nan],
+                "z": [np.nan, np.nan, 0, 1, 2],
+            },
+            index=exp_ind,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_rename_index(self):
+        a = DataFrame(
+            np.random.default_rng(2).random((3, 3)),
+            columns=list("ABC"),
+            index=Index(list("abc"), name="index_a"),
+        )
+        b = DataFrame(
+            np.random.default_rng(2).random((3, 3)),
+            columns=list("ABC"),
+            index=Index(list("abc"), name="index_b"),
+        )
+
+        result = concat([a, b], keys=["key0", "key1"], names=["lvl0", "lvl1"])
+
+        exp = concat([a, b], keys=["key0", "key1"], names=["lvl0"])
+        names = list(exp.index.names)
+        names[1] = "lvl1"
+        exp.index.set_names(names, inplace=True)
+
+        tm.assert_frame_equal(result, exp)
+        assert result.index.names == exp.index.names
+
+    def test_concat_copy_index_series(self, axis, using_copy_on_write):
+        # GH 29879
+        ser = Series([1, 2])
+        comb = concat([ser, ser], axis=axis, copy=True)
+        if not using_copy_on_write or axis in [0, "index"]:
+            assert comb.index is not ser.index
+        else:
+            assert comb.index is ser.index
+
+    def test_concat_copy_index_frame(self, axis, using_copy_on_write):
+        # GH 29879
+        df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"])
+        comb = concat([df, df], axis=axis, copy=True)
+        if not using_copy_on_write:
+            assert not comb.index.is_(df.index)
+            assert not comb.columns.is_(df.columns)
+        elif axis in [0, "index"]:
+            assert not comb.index.is_(df.index)
+            assert comb.columns.is_(df.columns)
+        elif axis in [1, "columns"]:
+            assert comb.index.is_(df.index)
+            assert not comb.columns.is_(df.columns)
+
+    def test_default_index(self):
+        # is_series and ignore_index
+        s1 = Series([1, 2, 3], name="x")
+        s2 = Series([4, 5, 6], name="y")
+        res = concat([s1, s2], axis=1, ignore_index=True)
+        assert isinstance(res.columns, pd.RangeIndex)
+        exp = DataFrame([[1, 4], [2, 5], [3, 6]])
+        # use check_index_type=True to check the result have
+        # RangeIndex (default index)
+        tm.assert_frame_equal(res, exp, check_index_type=True, check_column_type=True)
+
+        # is_series and all inputs have no names
+        s1 = Series([1, 2, 3])
+        s2 = Series([4, 5, 6])
+        res = concat([s1, s2], axis=1, ignore_index=False)
+        assert isinstance(res.columns, pd.RangeIndex)
+        exp = DataFrame([[1, 4], [2, 5], [3, 6]])
+        exp.columns = pd.RangeIndex(2)
+        tm.assert_frame_equal(res, exp, check_index_type=True, check_column_type=True)
+
+        # is_dataframe and ignore_index
+        df1 = DataFrame({"A": [1, 2], "B": [5, 6]})
+        df2 = DataFrame({"A": [3, 4], "B": [7, 8]})
+
+        res = concat([df1, df2], axis=0, ignore_index=True)
+        exp = DataFrame([[1, 5], [2, 6], [3, 7], [4, 8]], columns=["A", "B"])
+        tm.assert_frame_equal(res, exp, check_index_type=True, check_column_type=True)
+
+        res = concat([df1, df2], axis=1, ignore_index=True)
+        exp = DataFrame([[1, 5, 3, 7], [2, 6, 4, 8]])
+        tm.assert_frame_equal(res, exp, check_index_type=True, check_column_type=True)
+
+    def test_dups_index(self):
+        # GH 4771
+
+        # single dtypes
+        df = DataFrame(
+            np.random.default_rng(2).integers(0, 10, size=40).reshape(10, 4),
+            columns=["A", "A", "C", "C"],
+        )
+
+        result = concat([df, df], axis=1)
+        tm.assert_frame_equal(result.iloc[:, :4], df)
+        tm.assert_frame_equal(result.iloc[:, 4:], df)
+
+        result = concat([df, df], axis=0)
+        tm.assert_frame_equal(result.iloc[:10], df)
+        tm.assert_frame_equal(result.iloc[10:], df)
+
+        # multi dtypes
+        df = concat(
+            [
+                DataFrame(
+                    np.random.default_rng(2).standard_normal((10, 4)),
+                    columns=["A", "A", "B", "B"],
+                ),
+                DataFrame(
+                    np.random.default_rng(2).integers(0, 10, size=20).reshape(10, 2),
+                    columns=["A", "C"],
+                ),
+            ],
+            axis=1,
+        )
+
+        result = concat([df, df], axis=1)
+        tm.assert_frame_equal(result.iloc[:, :6], df)
+        tm.assert_frame_equal(result.iloc[:, 6:], df)
+
+        result = concat([df, df], axis=0)
+        tm.assert_frame_equal(result.iloc[:10], df)
+        tm.assert_frame_equal(result.iloc[10:], df)
+
+        # append
+        result = df.iloc[0:8, :]._append(df.iloc[8:])
+        tm.assert_frame_equal(result, df)
+
+        result = df.iloc[0:8, :]._append(df.iloc[8:9])._append(df.iloc[9:10])
+        tm.assert_frame_equal(result, df)
+
+        expected = concat([df, df], axis=0)
+        result = df._append(df)
+        tm.assert_frame_equal(result, expected)
+
+
+class TestMultiIndexConcat:
+    def test_concat_multiindex_with_keys(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        index = frame.index
+        result = concat([frame, frame], keys=[0, 1], names=["iteration"])
+
+        assert result.index.names == ("iteration",) + index.names
+        tm.assert_frame_equal(result.loc[0], frame)
+        tm.assert_frame_equal(result.loc[1], frame)
+        assert result.index.nlevels == 3
+
+    def test_concat_multiindex_with_none_in_index_names(self):
+        # GH 15787
+        index = MultiIndex.from_product([[1], range(5)], names=["level1", None])
+        df = DataFrame({"col": range(5)}, index=index, dtype=np.int32)
+
+        result = concat([df, df], keys=[1, 2], names=["level2"])
+        index = MultiIndex.from_product(
+            [[1, 2], [1], range(5)], names=["level2", "level1", None]
+        )
+        expected = DataFrame({"col": list(range(5)) * 2}, index=index, dtype=np.int32)
+        tm.assert_frame_equal(result, expected)
+
+        result = concat([df, df[:2]], keys=[1, 2], names=["level2"])
+        level2 = [1] * 5 + [2] * 2
+        level1 = [1] * 7
+        no_name = list(range(5)) + list(range(2))
+        tuples = list(zip(level2, level1, no_name))
+        index = MultiIndex.from_tuples(tuples, names=["level2", "level1", None])
+        expected = DataFrame({"col": no_name}, index=index, dtype=np.int32)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_multiindex_rangeindex(self):
+        # GH13542
+        # when multi-index levels are RangeIndex objects
+        # there is a bug in concat with objects of len 1
+
+        df = DataFrame(np.random.default_rng(2).standard_normal((9, 2)))
+        df.index = MultiIndex(
+            levels=[pd.RangeIndex(3), pd.RangeIndex(3)],
+            codes=[np.repeat(np.arange(3), 3), np.tile(np.arange(3), 3)],
+        )
+
+        res = concat([df.iloc[[2, 3, 4], :], df.iloc[[5], :]])
+        exp = df.iloc[[2, 3, 4, 5], :]
+        tm.assert_frame_equal(res, exp)
+
+    def test_concat_multiindex_dfs_with_deepcopy(self):
+        # GH 9967
+        example_multiindex1 = MultiIndex.from_product([["a"], ["b"]])
+        example_dataframe1 = DataFrame([0], index=example_multiindex1)
+
+        example_multiindex2 = MultiIndex.from_product([["a"], ["c"]])
+        example_dataframe2 = DataFrame([1], index=example_multiindex2)
+
+        example_dict = {"s1": example_dataframe1, "s2": example_dataframe2}
+        expected_index = MultiIndex(
+            levels=[["s1", "s2"], ["a"], ["b", "c"]],
+            codes=[[0, 1], [0, 0], [0, 1]],
+            names=["testname", None, None],
+        )
+        expected = DataFrame([[0], [1]], index=expected_index)
+        result_copy = concat(deepcopy(example_dict), names=["testname"])
+        tm.assert_frame_equal(result_copy, expected)
+        result_no_copy = concat(example_dict, names=["testname"])
+        tm.assert_frame_equal(result_no_copy, expected)
+
+    @pytest.mark.parametrize(
+        "mi1_list",
+        [
+            [["a"], range(2)],
+            [["b"], np.arange(2.0, 4.0)],
+            [["c"], ["A", "B"]],
+            [["d"], pd.date_range(start="2017", end="2018", periods=2)],
+        ],
+    )
+    @pytest.mark.parametrize(
+        "mi2_list",
+        [
+            [["a"], range(2)],
+            [["b"], np.arange(2.0, 4.0)],
+            [["c"], ["A", "B"]],
+            [["d"], pd.date_range(start="2017", end="2018", periods=2)],
+        ],
+    )
+    def test_concat_with_various_multiindex_dtypes(
+        self, mi1_list: list, mi2_list: list
+    ):
+        # GitHub #23478
+        mi1 = MultiIndex.from_product(mi1_list)
+        mi2 = MultiIndex.from_product(mi2_list)
+
+        df1 = DataFrame(np.zeros((1, len(mi1))), columns=mi1)
+        df2 = DataFrame(np.zeros((1, len(mi2))), columns=mi2)
+
+        if mi1_list[0] == mi2_list[0]:
+            expected_mi = MultiIndex(
+                levels=[mi1_list[0], list(mi1_list[1])],
+                codes=[[0, 0, 0, 0], [0, 1, 0, 1]],
+            )
+        else:
+            expected_mi = MultiIndex(
+                levels=[
+                    mi1_list[0] + mi2_list[0],
+                    list(mi1_list[1]) + list(mi2_list[1]),
+                ],
+                codes=[[0, 0, 1, 1], [0, 1, 2, 3]],
+            )
+
+        expected_df = DataFrame(np.zeros((1, len(expected_mi))), columns=expected_mi)
+
+        with tm.assert_produces_warning(None):
+            result_df = concat((df1, df2), axis=1)
+
+        tm.assert_frame_equal(expected_df, result_df)
+
+    def test_concat_multiindex_(self):
+        # GitHub #44786
+        df = DataFrame({"col": ["a", "b", "c"]}, index=["1", "2", "2"])
+        df = concat([df], keys=["X"])
+
+        iterables = [["X"], ["1", "2", "2"]]
+        result_index = df.index
+        expected_index = MultiIndex.from_product(iterables)
+
+        tm.assert_index_equal(result_index, expected_index)
+
+        result_df = df
+        expected_df = DataFrame(
+            {"col": ["a", "b", "c"]}, index=MultiIndex.from_product(iterables)
+        )
+        tm.assert_frame_equal(result_df, expected_df)
+
+    def test_concat_with_key_not_unique(self):
+        # GitHub #46519
+        df1 = DataFrame({"name": [1]})
+        df2 = DataFrame({"name": [2]})
+        df3 = DataFrame({"name": [3]})
+        df_a = concat([df1, df2, df3], keys=["x", "y", "x"])
+        # the warning is caused by indexing unsorted multi-index
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_a = df_a.loc[("x", 0), :]
+
+        df_b = DataFrame(
+            {"name": [1, 2, 3]}, index=Index([("x", 0), ("y", 0), ("x", 0)])
+        )
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_b = df_b.loc[("x", 0)]
+
+        tm.assert_frame_equal(out_a, out_b)
+
+        df1 = DataFrame({"name": ["a", "a", "b"]})
+        df2 = DataFrame({"name": ["a", "b"]})
+        df3 = DataFrame({"name": ["c", "d"]})
+        df_a = concat([df1, df2, df3], keys=["x", "y", "x"])
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_a = df_a.loc[("x", 0), :]
+
+        df_b = DataFrame(
+            {
+                "a": ["x", "x", "x", "y", "y", "x", "x"],
+                "b": [0, 1, 2, 0, 1, 0, 1],
+                "name": list("aababcd"),
+            }
+        ).set_index(["a", "b"])
+        df_b.index.names = [None, None]
+        with tm.assert_produces_warning(
+            PerformanceWarning, match="indexing past lexsort depth"
+        ):
+            out_b = df_b.loc[("x", 0), :]
+
+        tm.assert_frame_equal(out_a, out_b)
+
+    def test_concat_with_duplicated_levels(self):
+        # keyword levels should be unique
+        df1 = DataFrame({"A": [1]}, index=["x"])
+        df2 = DataFrame({"A": [1]}, index=["y"])
+        msg = r"Level values not unique: \['x', 'y', 'y'\]"
+        with pytest.raises(ValueError, match=msg):
+            concat([df1, df2], keys=["x", "y"], levels=[["x", "y", "y"]])
+
+    @pytest.mark.parametrize("levels", [[["x", "y"]], [["x", "y", "y"]]])
+    def test_concat_with_levels_with_none_keys(self, levels):
+        df1 = DataFrame({"A": [1]}, index=["x"])
+        df2 = DataFrame({"A": [1]}, index=["y"])
+        msg = "levels supported only when keys is not None"
+        with pytest.raises(ValueError, match=msg):
+            concat([df1, df2], levels=levels)
+
+    def test_concat_range_index_result(self):
+        # GH#47501
+        df1 = DataFrame({"a": [1, 2]})
+        df2 = DataFrame({"b": [1, 2]})
+
+        result = concat([df1, df2], sort=True, axis=1)
+        expected = DataFrame({"a": [1, 2], "b": [1, 2]})
+        tm.assert_frame_equal(result, expected)
+        expected_index = pd.RangeIndex(0, 2)
+        tm.assert_index_equal(result.index, expected_index, exact=True)
+
+    def test_concat_index_keep_dtype(self):
+        # GH#47329
+        df1 = DataFrame([[0, 1, 1]], columns=Index([1, 2, 3], dtype="object"))
+        df2 = DataFrame([[0, 1]], columns=Index([1, 2], dtype="object"))
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame(
+            [[0, 1, 1.0], [0, 1, np.nan]], columns=Index([1, 2, 3], dtype="object")
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_index_keep_dtype_ea_numeric(self, any_numeric_ea_dtype):
+        # GH#47329
+        df1 = DataFrame(
+            [[0, 1, 1]], columns=Index([1, 2, 3], dtype=any_numeric_ea_dtype)
+        )
+        df2 = DataFrame([[0, 1]], columns=Index([1, 2], dtype=any_numeric_ea_dtype))
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame(
+            [[0, 1, 1.0], [0, 1, np.nan]],
+            columns=Index([1, 2, 3], dtype=any_numeric_ea_dtype),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["Int8", "Int16", "Int32"])
+    def test_concat_index_find_common(self, dtype):
+        # GH#47329
+        df1 = DataFrame([[0, 1, 1]], columns=Index([1, 2, 3], dtype=dtype))
+        df2 = DataFrame([[0, 1]], columns=Index([1, 2], dtype="Int32"))
+        result = concat([df1, df2], ignore_index=True, join="outer", sort=True)
+        expected = DataFrame(
+            [[0, 1, 1.0], [0, 1, np.nan]], columns=Index([1, 2, 3], dtype="Int32")
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_axis_1_sort_false_rangeindex(self):
+        # GH 46675
+        s1 = Series(["a", "b", "c"])
+        s2 = Series(["a", "b"])
+        s3 = Series(["a", "b", "c", "d"])
+        s4 = Series([], dtype=object)
+        result = concat(
+            [s1, s2, s3, s4], sort=False, join="outer", ignore_index=False, axis=1
+        )
+        expected = DataFrame(
+            [
+                ["a"] * 3 + [np.nan],
+                ["b"] * 3 + [np.nan],
+                ["c", np.nan] * 2,
+                [np.nan] * 2 + ["d"] + [np.nan],
+            ],
+            dtype=object,
+        )
+        tm.assert_frame_equal(
+            result, expected, check_index_type=True, check_column_type=True
+        )
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_invalid.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_invalid.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e6703b185f27dd08f9fe9539328bfcb78457c54
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_invalid.py
@@ -0,0 +1,54 @@
+from io import StringIO
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    concat,
+    read_csv,
+)
+import pandas._testing as tm
+
+
+class TestInvalidConcat:
+    def test_concat_invalid(self):
+        # trying to concat a ndframe with a non-ndframe
+        df1 = tm.makeCustomDataframe(10, 2)
+        for obj in [1, {}, [1, 2], (1, 2)]:
+            msg = (
+                f"cannot concatenate object of type '{type(obj)}'; "
+                "only Series and DataFrame objs are valid"
+            )
+            with pytest.raises(TypeError, match=msg):
+                concat([df1, obj])
+
+    def test_concat_invalid_first_argument(self):
+        df1 = tm.makeCustomDataframe(10, 2)
+        msg = (
+            "first argument must be an iterable of pandas "
+            'objects, you passed an object of type "DataFrame"'
+        )
+        with pytest.raises(TypeError, match=msg):
+            concat(df1)
+
+    def test_concat_generator_obj(self):
+        # generator ok though
+        concat(DataFrame(np.random.default_rng(2).random((5, 5))) for _ in range(3))
+
+    def test_concat_textreader_obj(self):
+        # text reader ok
+        # GH6583
+        data = """index,A,B,C,D
+                  foo,2,3,4,5
+                  bar,7,8,9,10
+                  baz,12,13,14,15
+                  qux,12,13,14,15
+                  foo2,12,13,14,15
+                  bar2,12,13,14,15
+               """
+
+        with read_csv(StringIO(data), chunksize=1) as reader:
+            result = concat(reader, ignore_index=True)
+        expected = read_csv(StringIO(data))
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_series.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_series.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bef86ce6a941cbc24e39c5b90bc0ff6021fc22b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_series.py
@@ -0,0 +1,169 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    MultiIndex,
+    Series,
+    concat,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesConcat:
+    def test_concat_series(self):
+        ts = tm.makeTimeSeries()
+        ts.name = "foo"
+
+        pieces = [ts[:5], ts[5:15], ts[15:]]
+
+        result = concat(pieces)
+        tm.assert_series_equal(result, ts)
+        assert result.name == ts.name
+
+        result = concat(pieces, keys=[0, 1, 2])
+        expected = ts.copy()
+
+        ts.index = DatetimeIndex(np.array(ts.index.values, dtype="M8[ns]"))
+
+        exp_codes = [np.repeat([0, 1, 2], [len(x) for x in pieces]), np.arange(len(ts))]
+        exp_index = MultiIndex(levels=[[0, 1, 2], ts.index], codes=exp_codes)
+        expected.index = exp_index
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_empty_and_non_empty_series_regression(self):
+        # GH 18187 regression test
+        s1 = Series([1])
+        s2 = Series([], dtype=object)
+
+        expected = s1
+        msg = "The behavior of array concatenation with empty entries is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = concat([s1, s2])
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_series_axis1(self):
+        ts = tm.makeTimeSeries()
+
+        pieces = [ts[:-2], ts[2:], ts[2:-2]]
+
+        result = concat(pieces, axis=1)
+        expected = DataFrame(pieces).T
+        tm.assert_frame_equal(result, expected)
+
+        result = concat(pieces, keys=["A", "B", "C"], axis=1)
+        expected = DataFrame(pieces, index=["A", "B", "C"]).T
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_series_axis1_preserves_series_names(self):
+        # preserve series names, #2489
+        s = Series(np.random.default_rng(2).standard_normal(5), name="A")
+        s2 = Series(np.random.default_rng(2).standard_normal(5), name="B")
+
+        result = concat([s, s2], axis=1)
+        expected = DataFrame({"A": s, "B": s2})
+        tm.assert_frame_equal(result, expected)
+
+        s2.name = None
+        result = concat([s, s2], axis=1)
+        tm.assert_index_equal(result.columns, Index(["A", 0], dtype="object"))
+
+    def test_concat_series_axis1_with_reindex(self, sort):
+        # must reindex, #2603
+        s = Series(
+            np.random.default_rng(2).standard_normal(3), index=["c", "a", "b"], name="A"
+        )
+        s2 = Series(
+            np.random.default_rng(2).standard_normal(4),
+            index=["d", "a", "b", "c"],
+            name="B",
+        )
+        result = concat([s, s2], axis=1, sort=sort)
+        expected = DataFrame({"A": s, "B": s2}, index=["c", "a", "b", "d"])
+        if sort:
+            expected = expected.sort_index()
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_series_axis1_names_applied(self):
+        # ensure names argument is not ignored on axis=1, #23490
+        s = Series([1, 2, 3])
+        s2 = Series([4, 5, 6])
+        result = concat([s, s2], axis=1, keys=["a", "b"], names=["A"])
+        expected = DataFrame(
+            [[1, 4], [2, 5], [3, 6]], columns=Index(["a", "b"], name="A")
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = concat([s, s2], axis=1, keys=[("a", 1), ("b", 2)], names=["A", "B"])
+        expected = DataFrame(
+            [[1, 4], [2, 5], [3, 6]],
+            columns=MultiIndex.from_tuples([("a", 1), ("b", 2)], names=["A", "B"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_series_axis1_same_names_ignore_index(self):
+        dates = date_range("01-Jan-2013", "01-Jan-2014", freq="MS")[0:-1]
+        s1 = Series(
+            np.random.default_rng(2).standard_normal(len(dates)),
+            index=dates,
+            name="value",
+        )
+        s2 = Series(
+            np.random.default_rng(2).standard_normal(len(dates)),
+            index=dates,
+            name="value",
+        )
+
+        result = concat([s1, s2], axis=1, ignore_index=True)
+        expected = Index(range(2))
+
+        tm.assert_index_equal(result.columns, expected, exact=True)
+
+    @pytest.mark.parametrize(
+        "s1name,s2name", [(np.int64(190), (43, 0)), (190, (43, 0))]
+    )
+    def test_concat_series_name_npscalar_tuple(self, s1name, s2name):
+        # GH21015
+        s1 = Series({"a": 1, "b": 2}, name=s1name)
+        s2 = Series({"c": 5, "d": 6}, name=s2name)
+        result = concat([s1, s2])
+        expected = Series({"a": 1, "b": 2, "c": 5, "d": 6})
+        tm.assert_series_equal(result, expected)
+
+    def test_concat_series_partial_columns_names(self):
+        # GH10698
+        named_series = Series([1, 2], name="foo")
+        unnamed_series1 = Series([1, 2])
+        unnamed_series2 = Series([4, 5])
+
+        result = concat([named_series, unnamed_series1, unnamed_series2], axis=1)
+        expected = DataFrame(
+            {"foo": [1, 2], 0: [1, 2], 1: [4, 5]}, columns=["foo", 0, 1]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = concat(
+            [named_series, unnamed_series1, unnamed_series2],
+            axis=1,
+            keys=["red", "blue", "yellow"],
+        )
+        expected = DataFrame(
+            {"red": [1, 2], "blue": [1, 2], "yellow": [4, 5]},
+            columns=["red", "blue", "yellow"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = concat(
+            [named_series, unnamed_series1, unnamed_series2], axis=1, ignore_index=True
+        )
+        expected = DataFrame({0: [1, 2], 1: [1, 2], 2: [4, 5]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_series_length_one_reversed(self, frame_or_series):
+        # GH39401
+        obj = frame_or_series([100])
+        result = concat([obj.iloc[::-1]])
+        tm.assert_equal(result, obj)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_sort.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_sort.py
new file mode 100644
index 0000000000000000000000000000000000000000..2724f819588933cc307dd396fdcd024f04c38eaa
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/concat/test_sort.py
@@ -0,0 +1,118 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestConcatSort:
+    def test_concat_sorts_columns(self, sort):
+        # GH-4588
+        df1 = DataFrame({"a": [1, 2], "b": [1, 2]}, columns=["b", "a"])
+        df2 = DataFrame({"a": [3, 4], "c": [5, 6]})
+
+        # for sort=True/None
+        expected = DataFrame(
+            {"a": [1, 2, 3, 4], "b": [1, 2, None, None], "c": [None, None, 5, 6]},
+            columns=["a", "b", "c"],
+        )
+
+        if sort is False:
+            expected = expected[["b", "a", "c"]]
+
+        # default
+        with tm.assert_produces_warning(None):
+            result = pd.concat([df1, df2], ignore_index=True, sort=sort)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_sorts_index(self, sort):
+        df1 = DataFrame({"a": [1, 2, 3]}, index=["c", "a", "b"])
+        df2 = DataFrame({"b": [1, 2]}, index=["a", "b"])
+
+        # For True/None
+        expected = DataFrame(
+            {"a": [2, 3, 1], "b": [1, 2, None]},
+            index=["a", "b", "c"],
+            columns=["a", "b"],
+        )
+        if sort is False:
+            expected = expected.loc[["c", "a", "b"]]
+
+        # Warn and sort by default
+        with tm.assert_produces_warning(None):
+            result = pd.concat([df1, df2], axis=1, sort=sort)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_inner_sort(self, sort):
+        # https://github.com/pandas-dev/pandas/pull/20613
+        df1 = DataFrame(
+            {"a": [1, 2], "b": [1, 2], "c": [1, 2]}, columns=["b", "a", "c"]
+        )
+        df2 = DataFrame({"a": [1, 2], "b": [3, 4]}, index=[3, 4])
+
+        with tm.assert_produces_warning(None):
+            # unset sort should *not* warn for inner join
+            # since that never sorted
+            result = pd.concat([df1, df2], sort=sort, join="inner", ignore_index=True)
+
+        expected = DataFrame({"b": [1, 2, 3, 4], "a": [1, 2, 1, 2]}, columns=["b", "a"])
+        if sort is True:
+            expected = expected[["a", "b"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_aligned_sort(self):
+        # GH-4588
+        df = DataFrame({"c": [1, 2], "b": [3, 4], "a": [5, 6]}, columns=["c", "b", "a"])
+        result = pd.concat([df, df], sort=True, ignore_index=True)
+        expected = DataFrame(
+            {"a": [5, 6, 5, 6], "b": [3, 4, 3, 4], "c": [1, 2, 1, 2]},
+            columns=["a", "b", "c"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = pd.concat(
+            [df, df[["c", "b"]]], join="inner", sort=True, ignore_index=True
+        )
+        expected = expected[["b", "c"]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_aligned_sort_does_not_raise(self):
+        # GH-4588
+        # We catch TypeErrors from sorting internally and do not re-raise.
+        df = DataFrame({1: [1, 2], "a": [3, 4]}, columns=[1, "a"])
+        expected = DataFrame({1: [1, 2, 1, 2], "a": [3, 4, 3, 4]}, columns=[1, "a"])
+        result = pd.concat([df, df], ignore_index=True, sort=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_frame_with_sort_false(self):
+        # GH 43375
+        result = pd.concat(
+            [DataFrame({i: i}, index=[i]) for i in range(2, 0, -1)], sort=False
+        )
+        expected = DataFrame([[2, np.nan], [np.nan, 1]], index=[2, 1], columns=[2, 1])
+
+        tm.assert_frame_equal(result, expected)
+
+        # GH 37937
+        df1 = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=[1, 2, 3])
+        df2 = DataFrame({"c": [7, 8, 9], "d": [10, 11, 12]}, index=[3, 1, 6])
+        result = pd.concat([df2, df1], axis=1, sort=False)
+        expected = DataFrame(
+            [
+                [7.0, 10.0, 3.0, 6.0],
+                [8.0, 11.0, 1.0, 4.0],
+                [9.0, 12.0, np.nan, np.nan],
+                [np.nan, np.nan, 2.0, 5.0],
+            ],
+            index=[3, 1, 6, 2],
+            columns=["c", "d", "a", "b"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_concat_sort_none_raises(self):
+        # GH#41518
+        df = DataFrame({1: [1, 2], "a": [3, 4]})
+        msg = "The 'sort' keyword only accepts boolean values; None was passed."
+        with pytest.raises(ValueError, match=msg):
+            pd.concat([df, df], sort=None)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..375056120a704ae67cf096da35ef53e8d3d14f62
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_join.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_join.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8717ec9eadf906bd7051d911684b99201fad4b19
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_join.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d7b29d71b2b6265536fdb9e1150b5624f9738716
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ab65824f1aeace8f9fa5ce36611d48ff8da0d3926efb4ec0fae98d07ed0a50d
+size 130420
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_asof.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_asof.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da4c867575f36375e123613922501ab8790564e0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_asof.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_cross.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_cross.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a256da807477882c2340b74ce07ae2520d16cfd
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_cross.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_index_as_string.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_index_as_string.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72356fe89df1673190ca4e2ceaba8b3c568afb98
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_index_as_string.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_ordered.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_ordered.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23ec5330da1abd46aee42211be2ee361506eb2ce
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge_ordered.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_multi.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_multi.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b7427aa5610ad05421a6a73d3f323e64b9e68a4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/__pycache__/test_multi.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_join.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb6bdba4c7f54097b01e928b38b6e09b96f44a41
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_join.py
@@ -0,0 +1,1056 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    concat,
+    merge,
+)
+import pandas._testing as tm
+
+
+def get_test_data(ngroups=8, n=50):
+    unique_groups = list(range(ngroups))
+    arr = np.asarray(np.tile(unique_groups, n // ngroups))
+
+    if len(arr) < n:
+        arr = np.asarray(list(arr) + unique_groups[: n - len(arr)])
+
+    np.random.default_rng(2).shuffle(arr)
+    return arr
+
+
+class TestJoin:
+    # aggregate multiple columns
+    @pytest.fixture
+    def df(self):
+        df = DataFrame(
+            {
+                "key1": get_test_data(),
+                "key2": get_test_data(),
+                "data1": np.random.default_rng(2).standard_normal(50),
+                "data2": np.random.default_rng(2).standard_normal(50),
+            }
+        )
+
+        # exclude a couple keys for fun
+        df = df[df["key2"] > 1]
+        return df
+
+    @pytest.fixture
+    def df2(self):
+        return DataFrame(
+            {
+                "key1": get_test_data(n=10),
+                "key2": get_test_data(ngroups=4, n=10),
+                "value": np.random.default_rng(2).standard_normal(10),
+            }
+        )
+
+    @pytest.fixture
+    def target_source(self):
+        index, data = tm.getMixedTypeDict()
+        target = DataFrame(data, index=index)
+
+        # Join on string value
+
+        source = DataFrame(
+            {"MergedA": data["A"], "MergedD": data["D"]}, index=data["C"]
+        )
+        return target, source
+
+    def test_left_outer_join(self, df, df2):
+        joined_key2 = merge(df, df2, on="key2")
+        _check_join(df, df2, joined_key2, ["key2"], how="left")
+
+        joined_both = merge(df, df2)
+        _check_join(df, df2, joined_both, ["key1", "key2"], how="left")
+
+    def test_right_outer_join(self, df, df2):
+        joined_key2 = merge(df, df2, on="key2", how="right")
+        _check_join(df, df2, joined_key2, ["key2"], how="right")
+
+        joined_both = merge(df, df2, how="right")
+        _check_join(df, df2, joined_both, ["key1", "key2"], how="right")
+
+    def test_full_outer_join(self, df, df2):
+        joined_key2 = merge(df, df2, on="key2", how="outer")
+        _check_join(df, df2, joined_key2, ["key2"], how="outer")
+
+        joined_both = merge(df, df2, how="outer")
+        _check_join(df, df2, joined_both, ["key1", "key2"], how="outer")
+
+    def test_inner_join(self, df, df2):
+        joined_key2 = merge(df, df2, on="key2", how="inner")
+        _check_join(df, df2, joined_key2, ["key2"], how="inner")
+
+        joined_both = merge(df, df2, how="inner")
+        _check_join(df, df2, joined_both, ["key1", "key2"], how="inner")
+
+    def test_handle_overlap(self, df, df2):
+        joined = merge(df, df2, on="key2", suffixes=(".foo", ".bar"))
+
+        assert "key1.foo" in joined
+        assert "key1.bar" in joined
+
+    def test_handle_overlap_arbitrary_key(self, df, df2):
+        joined = merge(
+            df,
+            df2,
+            left_on="key2",
+            right_on="key1",
+            suffixes=(".foo", ".bar"),
+        )
+        assert "key1.foo" in joined
+        assert "key2.bar" in joined
+
+    def test_join_on(self, target_source):
+        target, source = target_source
+
+        merged = target.join(source, on="C")
+        tm.assert_series_equal(merged["MergedA"], target["A"], check_names=False)
+        tm.assert_series_equal(merged["MergedD"], target["D"], check_names=False)
+
+        # join with duplicates (fix regression from DataFrame/Matrix merge)
+        df = DataFrame({"key": ["a", "a", "b", "b", "c"]})
+        df2 = DataFrame({"value": [0, 1, 2]}, index=["a", "b", "c"])
+        joined = df.join(df2, on="key")
+        expected = DataFrame(
+            {"key": ["a", "a", "b", "b", "c"], "value": [0, 0, 1, 1, 2]}
+        )
+        tm.assert_frame_equal(joined, expected)
+
+        # Test when some are missing
+        df_a = DataFrame([[1], [2], [3]], index=["a", "b", "c"], columns=["one"])
+        df_b = DataFrame([["foo"], ["bar"]], index=[1, 2], columns=["two"])
+        df_c = DataFrame([[1], [2]], index=[1, 2], columns=["three"])
+        joined = df_a.join(df_b, on="one")
+        joined = joined.join(df_c, on="one")
+        assert np.isnan(joined["two"]["c"])
+        assert np.isnan(joined["three"]["c"])
+
+        # merge column not p resent
+        with pytest.raises(KeyError, match="^'E'$"):
+            target.join(source, on="E")
+
+        # overlap
+        source_copy = source.copy()
+        msg = (
+            "You are trying to merge on float64 and object columns for key 'A'. "
+            "If you wish to proceed you should use pd.concat"
+        )
+        with pytest.raises(ValueError, match=msg):
+            target.join(source_copy, on="A")
+
+    def test_join_on_fails_with_different_right_index(self):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).choice(["m", "f"], size=3),
+                "b": np.random.default_rng(2).standard_normal(3),
+            }
+        )
+        df2 = DataFrame(
+            {
+                "a": np.random.default_rng(2).choice(["m", "f"], size=10),
+                "b": np.random.default_rng(2).standard_normal(10),
+            },
+            index=tm.makeCustomIndex(10, 2),
+        )
+        msg = r'len\(left_on\) must equal the number of levels in the index of "right"'
+        with pytest.raises(ValueError, match=msg):
+            merge(df, df2, left_on="a", right_index=True)
+
+    def test_join_on_fails_with_different_left_index(self):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).choice(["m", "f"], size=3),
+                "b": np.random.default_rng(2).standard_normal(3),
+            },
+            index=tm.makeCustomIndex(3, 2),
+        )
+        df2 = DataFrame(
+            {
+                "a": np.random.default_rng(2).choice(["m", "f"], size=10),
+                "b": np.random.default_rng(2).standard_normal(10),
+            }
+        )
+        msg = r'len\(right_on\) must equal the number of levels in the index of "left"'
+        with pytest.raises(ValueError, match=msg):
+            merge(df, df2, right_on="b", left_index=True)
+
+    def test_join_on_fails_with_different_column_counts(self):
+        df = DataFrame(
+            {
+                "a": np.random.default_rng(2).choice(["m", "f"], size=3),
+                "b": np.random.default_rng(2).standard_normal(3),
+            }
+        )
+        df2 = DataFrame(
+            {
+                "a": np.random.default_rng(2).choice(["m", "f"], size=10),
+                "b": np.random.default_rng(2).standard_normal(10),
+            },
+            index=tm.makeCustomIndex(10, 2),
+        )
+        msg = r"len\(right_on\) must equal len\(left_on\)"
+        with pytest.raises(ValueError, match=msg):
+            merge(df, df2, right_on="a", left_on=["a", "b"])
+
+    @pytest.mark.parametrize("wrong_type", [2, "str", None, np.array([0, 1])])
+    def test_join_on_fails_with_wrong_object_type(self, wrong_type):
+        # GH12081 - original issue
+
+        # GH21220 - merging of Series and DataFrame is now allowed
+        # Edited test to remove the Series object from test parameters
+
+        df = DataFrame({"a": [1, 1]})
+        msg = (
+            "Can only merge Series or DataFrame objects, "
+            f"a {type(wrong_type)} was passed"
+        )
+        with pytest.raises(TypeError, match=msg):
+            merge(wrong_type, df, left_on="a", right_on="a")
+        with pytest.raises(TypeError, match=msg):
+            merge(df, wrong_type, left_on="a", right_on="a")
+
+    def test_join_on_pass_vector(self, target_source):
+        target, source = target_source
+        expected = target.join(source, on="C")
+        del expected["C"]
+
+        join_col = target.pop("C")
+        result = target.join(source, on=join_col)
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_with_len0(self, target_source):
+        # nothing to merge
+        target, source = target_source
+        merged = target.join(source.reindex([]), on="C")
+        for col in source:
+            assert col in merged
+            assert merged[col].isna().all()
+
+        merged2 = target.join(source.reindex([]), on="C", how="inner")
+        tm.assert_index_equal(merged2.columns, merged.columns)
+        assert len(merged2) == 0
+
+    def test_join_on_inner(self):
+        df = DataFrame({"key": ["a", "a", "d", "b", "b", "c"]})
+        df2 = DataFrame({"value": [0, 1]}, index=["a", "b"])
+
+        joined = df.join(df2, on="key", how="inner")
+
+        expected = df.join(df2, on="key")
+        expected = expected[expected["value"].notna()]
+        tm.assert_series_equal(joined["key"], expected["key"])
+        tm.assert_series_equal(joined["value"], expected["value"], check_dtype=False)
+        tm.assert_index_equal(joined.index, expected.index)
+
+    def test_join_on_singlekey_list(self):
+        df = DataFrame({"key": ["a", "a", "b", "b", "c"]})
+        df2 = DataFrame({"value": [0, 1, 2]}, index=["a", "b", "c"])
+
+        # corner cases
+        joined = df.join(df2, on=["key"])
+        expected = df.join(df2, on="key")
+
+        tm.assert_frame_equal(joined, expected)
+
+    def test_join_on_series(self, target_source):
+        target, source = target_source
+        result = target.join(source["MergedA"], on="C")
+        expected = target.join(source[["MergedA"]], on="C")
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_on_series_buglet(self):
+        # GH #638
+        df = DataFrame({"a": [1, 1]})
+        ds = Series([2], index=[1], name="b")
+        result = df.join(ds, on="a")
+        expected = DataFrame({"a": [1, 1], "b": [2, 2]}, index=df.index)
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_index_mixed(self, join_type):
+        # no overlapping blocks
+        df1 = DataFrame(index=np.arange(10))
+        df1["bool"] = True
+        df1["string"] = "foo"
+
+        df2 = DataFrame(index=np.arange(5, 15))
+        df2["int"] = 1
+        df2["float"] = 1.0
+
+        joined = df1.join(df2, how=join_type)
+        expected = _join_by_hand(df1, df2, how=join_type)
+        tm.assert_frame_equal(joined, expected)
+
+        joined = df2.join(df1, how=join_type)
+        expected = _join_by_hand(df2, df1, how=join_type)
+        tm.assert_frame_equal(joined, expected)
+
+    def test_join_index_mixed_overlap(self):
+        df1 = DataFrame(
+            {"A": 1.0, "B": 2, "C": "foo", "D": True},
+            index=np.arange(10),
+            columns=["A", "B", "C", "D"],
+        )
+        assert df1["B"].dtype == np.int64
+        assert df1["D"].dtype == np.bool_
+
+        df2 = DataFrame(
+            {"A": 1.0, "B": 2, "C": "foo", "D": True},
+            index=np.arange(0, 10, 2),
+            columns=["A", "B", "C", "D"],
+        )
+
+        # overlap
+        joined = df1.join(df2, lsuffix="_one", rsuffix="_two")
+        expected_columns = [
+            "A_one",
+            "B_one",
+            "C_one",
+            "D_one",
+            "A_two",
+            "B_two",
+            "C_two",
+            "D_two",
+        ]
+        df1.columns = expected_columns[:4]
+        df2.columns = expected_columns[4:]
+        expected = _join_by_hand(df1, df2)
+        tm.assert_frame_equal(joined, expected)
+
+    def test_join_empty_bug(self):
+        # generated an exception in 0.4.3
+        x = DataFrame()
+        x.join(DataFrame([3], index=[0], columns=["A"]), how="outer")
+
+    def test_join_unconsolidated(self):
+        # GH #331
+        a = DataFrame(
+            np.random.default_rng(2).standard_normal((30, 2)), columns=["a", "b"]
+        )
+        c = Series(np.random.default_rng(2).standard_normal(30))
+        a["c"] = c
+        d = DataFrame(np.random.default_rng(2).standard_normal((30, 1)), columns=["q"])
+
+        # it works!
+        a.join(d)
+        d.join(a)
+
+    def test_join_multiindex(self):
+        index1 = MultiIndex.from_arrays(
+            [["a", "a", "a", "b", "b", "b"], [1, 2, 3, 1, 2, 3]],
+            names=["first", "second"],
+        )
+
+        index2 = MultiIndex.from_arrays(
+            [["b", "b", "b", "c", "c", "c"], [1, 2, 3, 1, 2, 3]],
+            names=["first", "second"],
+        )
+
+        df1 = DataFrame(
+            data=np.random.default_rng(2).standard_normal(6),
+            index=index1,
+            columns=["var X"],
+        )
+        df2 = DataFrame(
+            data=np.random.default_rng(2).standard_normal(6),
+            index=index2,
+            columns=["var Y"],
+        )
+
+        df1 = df1.sort_index(level=0)
+        df2 = df2.sort_index(level=0)
+
+        joined = df1.join(df2, how="outer")
+        ex_index = Index(index1.values).union(Index(index2.values))
+        expected = df1.reindex(ex_index).join(df2.reindex(ex_index))
+        expected.index.names = index1.names
+        tm.assert_frame_equal(joined, expected)
+        assert joined.index.names == index1.names
+
+        df1 = df1.sort_index(level=1)
+        df2 = df2.sort_index(level=1)
+
+        joined = df1.join(df2, how="outer").sort_index(level=0)
+        ex_index = Index(index1.values).union(Index(index2.values))
+        expected = df1.reindex(ex_index).join(df2.reindex(ex_index))
+        expected.index.names = index1.names
+
+        tm.assert_frame_equal(joined, expected)
+        assert joined.index.names == index1.names
+
+    def test_join_inner_multiindex(self, lexsorted_two_level_string_multiindex):
+        key1 = ["bar", "bar", "bar", "foo", "foo", "baz", "baz", "qux", "qux", "snap"]
+        key2 = [
+            "two",
+            "one",
+            "three",
+            "one",
+            "two",
+            "one",
+            "two",
+            "two",
+            "three",
+            "one",
+        ]
+
+        data = np.random.default_rng(2).standard_normal(len(key1))
+        data = DataFrame({"key1": key1, "key2": key2, "data": data})
+
+        index = lexsorted_two_level_string_multiindex
+        to_join = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 3)),
+            index=index,
+            columns=["j_one", "j_two", "j_three"],
+        )
+
+        joined = data.join(to_join, on=["key1", "key2"], how="inner")
+        expected = merge(
+            data,
+            to_join.reset_index(),
+            left_on=["key1", "key2"],
+            right_on=["first", "second"],
+            how="inner",
+            sort=False,
+        )
+
+        expected2 = merge(
+            to_join,
+            data,
+            right_on=["key1", "key2"],
+            left_index=True,
+            how="inner",
+            sort=False,
+        )
+        tm.assert_frame_equal(joined, expected2.reindex_like(joined))
+
+        expected2 = merge(
+            to_join,
+            data,
+            right_on=["key1", "key2"],
+            left_index=True,
+            how="inner",
+            sort=False,
+        )
+
+        expected = expected.drop(["first", "second"], axis=1)
+        expected.index = joined.index
+
+        assert joined.index.is_monotonic_increasing
+        tm.assert_frame_equal(joined, expected)
+
+        # _assert_same_contents(expected, expected2.loc[:, expected.columns])
+
+    def test_join_hierarchical_mixed_raises(self):
+        # GH 2024
+        # GH 40993: For raising, enforced in 2.0
+        df = DataFrame([(1, 2, 3), (4, 5, 6)], columns=["a", "b", "c"])
+        new_df = df.groupby(["a"]).agg({"b": ["mean", "sum"]})
+        other_df = DataFrame([(1, 2, 3), (7, 10, 6)], columns=["a", "b", "d"])
+        other_df.set_index("a", inplace=True)
+        # GH 9455, 12219
+        with pytest.raises(
+            pd.errors.MergeError, match="Not allowed to merge between different levels"
+        ):
+            merge(new_df, other_df, left_index=True, right_index=True)
+
+    def test_join_float64_float32(self):
+        a = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 2)),
+            columns=["a", "b"],
+            dtype=np.float64,
+        )
+        b = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 1)),
+            columns=["c"],
+            dtype=np.float32,
+        )
+        joined = a.join(b)
+        assert joined.dtypes["a"] == "float64"
+        assert joined.dtypes["b"] == "float64"
+        assert joined.dtypes["c"] == "float32"
+
+        a = np.random.default_rng(2).integers(0, 5, 100).astype("int64")
+        b = np.random.default_rng(2).random(100).astype("float64")
+        c = np.random.default_rng(2).random(100).astype("float32")
+        df = DataFrame({"a": a, "b": b, "c": c})
+        xpdf = DataFrame({"a": a, "b": b, "c": c})
+        s = DataFrame(
+            np.random.default_rng(2).random(5).astype("float32"), columns=["md"]
+        )
+        rs = df.merge(s, left_on="a", right_index=True)
+        assert rs.dtypes["a"] == "int64"
+        assert rs.dtypes["b"] == "float64"
+        assert rs.dtypes["c"] == "float32"
+        assert rs.dtypes["md"] == "float32"
+
+        xp = xpdf.merge(s, left_on="a", right_index=True)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_join_many_non_unique_index(self):
+        df1 = DataFrame({"a": [1, 1], "b": [1, 1], "c": [10, 20]})
+        df2 = DataFrame({"a": [1, 1], "b": [1, 2], "d": [100, 200]})
+        df3 = DataFrame({"a": [1, 1], "b": [1, 2], "e": [1000, 2000]})
+        idf1 = df1.set_index(["a", "b"])
+        idf2 = df2.set_index(["a", "b"])
+        idf3 = df3.set_index(["a", "b"])
+
+        result = idf1.join([idf2, idf3], how="outer")
+
+        df_partially_merged = merge(df1, df2, on=["a", "b"], how="outer")
+        expected = merge(df_partially_merged, df3, on=["a", "b"], how="outer")
+
+        result = result.reset_index()
+        expected = expected[result.columns]
+        expected["a"] = expected.a.astype("int64")
+        expected["b"] = expected.b.astype("int64")
+        tm.assert_frame_equal(result, expected)
+
+        df1 = DataFrame({"a": [1, 1, 1], "b": [1, 1, 1], "c": [10, 20, 30]})
+        df2 = DataFrame({"a": [1, 1, 1], "b": [1, 1, 2], "d": [100, 200, 300]})
+        df3 = DataFrame({"a": [1, 1, 1], "b": [1, 1, 2], "e": [1000, 2000, 3000]})
+        idf1 = df1.set_index(["a", "b"])
+        idf2 = df2.set_index(["a", "b"])
+        idf3 = df3.set_index(["a", "b"])
+        result = idf1.join([idf2, idf3], how="inner")
+
+        df_partially_merged = merge(df1, df2, on=["a", "b"], how="inner")
+        expected = merge(df_partially_merged, df3, on=["a", "b"], how="inner")
+
+        result = result.reset_index()
+
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
+
+        # GH 11519
+        df = DataFrame(
+            {
+                "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
+                "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
+                "C": np.random.default_rng(2).standard_normal(8),
+                "D": np.random.default_rng(2).standard_normal(8),
+            }
+        )
+        s = Series(
+            np.repeat(np.arange(8), 2), index=np.repeat(np.arange(8), 2), name="TEST"
+        )
+        inner = df.join(s, how="inner")
+        outer = df.join(s, how="outer")
+        left = df.join(s, how="left")
+        right = df.join(s, how="right")
+        tm.assert_frame_equal(inner, outer)
+        tm.assert_frame_equal(inner, left)
+        tm.assert_frame_equal(inner, right)
+
+    def test_join_sort(self):
+        left = DataFrame({"key": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 4]})
+        right = DataFrame({"value2": ["a", "b", "c"]}, index=["bar", "baz", "foo"])
+
+        joined = left.join(right, on="key", sort=True)
+        expected = DataFrame(
+            {
+                "key": ["bar", "baz", "foo", "foo"],
+                "value": [2, 3, 1, 4],
+                "value2": ["a", "b", "c", "c"],
+            },
+            index=[1, 2, 0, 3],
+        )
+        tm.assert_frame_equal(joined, expected)
+
+        # smoke test
+        joined = left.join(right, on="key", sort=False)
+        tm.assert_index_equal(joined.index, Index(range(4)), exact=True)
+
+    def test_join_mixed_non_unique_index(self):
+        # GH 12814, unorderable types in py3 with a non-unique index
+        df1 = DataFrame({"a": [1, 2, 3, 4]}, index=[1, 2, 3, "a"])
+        df2 = DataFrame({"b": [5, 6, 7, 8]}, index=[1, 3, 3, 4])
+        result = df1.join(df2)
+        expected = DataFrame(
+            {"a": [1, 2, 3, 3, 4], "b": [5, np.nan, 6, 7, np.nan]},
+            index=[1, 2, 3, 3, "a"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+        df3 = DataFrame({"a": [1, 2, 3, 4]}, index=[1, 2, 2, "a"])
+        df4 = DataFrame({"b": [5, 6, 7, 8]}, index=[1, 2, 3, 4])
+        result = df3.join(df4)
+        expected = DataFrame(
+            {"a": [1, 2, 3, 4], "b": [5, 6, 6, np.nan]}, index=[1, 2, 2, "a"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_non_unique_period_index(self):
+        # GH #16871
+        index = pd.period_range("2016-01-01", periods=16, freq="M")
+        df = DataFrame(list(range(len(index))), index=index, columns=["pnum"])
+        df2 = concat([df, df])
+        result = df.join(df2, how="inner", rsuffix="_df2")
+        expected = DataFrame(
+            np.tile(np.arange(16, dtype=np.int64).repeat(2).reshape(-1, 1), 2),
+            columns=["pnum", "pnum_df2"],
+            index=df2.sort_index().index,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_mixed_type_join_with_suffix(self):
+        # GH #916
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((20, 6)),
+            columns=["a", "b", "c", "d", "e", "f"],
+        )
+        df.insert(0, "id", 0)
+        df.insert(5, "dt", "foo")
+
+        grouped = df.groupby("id")
+        msg = re.escape("agg function failed [how->mean,dtype->object]")
+        with pytest.raises(TypeError, match=msg):
+            grouped.mean()
+        mn = grouped.mean(numeric_only=True)
+        cn = grouped.count()
+
+        # it works!
+        mn.join(cn, rsuffix="_right")
+
+    def test_join_many(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 6)), columns=list("abcdef")
+        )
+        df_list = [df[["a", "b"]], df[["c", "d"]], df[["e", "f"]]]
+
+        joined = df_list[0].join(df_list[1:])
+        tm.assert_frame_equal(joined, df)
+
+        df_list = [df[["a", "b"]][:-2], df[["c", "d"]][2:], df[["e", "f"]][1:9]]
+
+        def _check_diff_index(df_list, result, exp_index):
+            reindexed = [x.reindex(exp_index) for x in df_list]
+            expected = reindexed[0].join(reindexed[1:])
+            tm.assert_frame_equal(result, expected)
+
+        # different join types
+        joined = df_list[0].join(df_list[1:], how="outer")
+        _check_diff_index(df_list, joined, df.index)
+
+        joined = df_list[0].join(df_list[1:])
+        _check_diff_index(df_list, joined, df_list[0].index)
+
+        joined = df_list[0].join(df_list[1:], how="inner")
+        _check_diff_index(df_list, joined, df.index[2:8])
+
+        msg = "Joining multiple DataFrames only supported for joining on index"
+        with pytest.raises(ValueError, match=msg):
+            df_list[0].join(df_list[1:], on="a")
+
+    def test_join_many_mixed(self):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((8, 4)),
+            columns=["A", "B", "C", "D"],
+        )
+        df["key"] = ["foo", "bar"] * 4
+        df1 = df.loc[:, ["A", "B"]]
+        df2 = df.loc[:, ["C", "D"]]
+        df3 = df.loc[:, ["key"]]
+
+        result = df1.join([df2, df3])
+        tm.assert_frame_equal(result, df)
+
+    def test_join_dups(self):
+        # joining dups
+        df = concat(
+            [
+                DataFrame(
+                    np.random.default_rng(2).standard_normal((10, 4)),
+                    columns=["A", "A", "B", "B"],
+                ),
+                DataFrame(
+                    np.random.default_rng(2).integers(0, 10, size=20).reshape(10, 2),
+                    columns=["A", "C"],
+                ),
+            ],
+            axis=1,
+        )
+
+        expected = concat([df, df], axis=1)
+        result = df.join(df, rsuffix="_2")
+        result.columns = expected.columns
+        tm.assert_frame_equal(result, expected)
+
+        # GH 4975, invalid join on dups
+        w = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 2)), columns=["x", "y"]
+        )
+        x = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 2)), columns=["x", "y"]
+        )
+        y = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 2)), columns=["x", "y"]
+        )
+        z = DataFrame(
+            np.random.default_rng(2).standard_normal((4, 2)), columns=["x", "y"]
+        )
+
+        dta = x.merge(y, left_index=True, right_index=True).merge(
+            z, left_index=True, right_index=True, how="outer"
+        )
+        # GH 40991: As of 2.0 causes duplicate columns
+        with pytest.raises(
+            pd.errors.MergeError,
+            match="Passing 'suffixes' which cause duplicate columns",
+        ):
+            dta.merge(w, left_index=True, right_index=True)
+
+    def test_join_multi_to_multi(self, join_type):
+        # GH 20475
+        leftindex = MultiIndex.from_product(
+            [list("abc"), list("xy"), [1, 2]], names=["abc", "xy", "num"]
+        )
+        left = DataFrame({"v1": range(12)}, index=leftindex)
+
+        rightindex = MultiIndex.from_product(
+            [list("abc"), list("xy")], names=["abc", "xy"]
+        )
+        right = DataFrame({"v2": [100 * i for i in range(1, 7)]}, index=rightindex)
+
+        result = left.join(right, on=["abc", "xy"], how=join_type)
+        expected = (
+            left.reset_index()
+            .merge(right.reset_index(), on=["abc", "xy"], how=join_type)
+            .set_index(["abc", "xy", "num"])
+        )
+        tm.assert_frame_equal(expected, result)
+
+        msg = r'len\(left_on\) must equal the number of levels in the index of "right"'
+        with pytest.raises(ValueError, match=msg):
+            left.join(right, on="xy", how=join_type)
+
+        with pytest.raises(ValueError, match=msg):
+            right.join(left, on=["abc", "xy"], how=join_type)
+
+    def test_join_on_tz_aware_datetimeindex(self):
+        # GH 23931, 26335
+        df1 = DataFrame(
+            {
+                "date": pd.date_range(
+                    start="2018-01-01", periods=5, tz="America/Chicago"
+                ),
+                "vals": list("abcde"),
+            }
+        )
+
+        df2 = DataFrame(
+            {
+                "date": pd.date_range(
+                    start="2018-01-03", periods=5, tz="America/Chicago"
+                ),
+                "vals_2": list("tuvwx"),
+            }
+        )
+        result = df1.join(df2.set_index("date"), on="date")
+        expected = df1.copy()
+        expected["vals_2"] = Series([np.nan] * 2 + list("tuv"), dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_datetime_string(self):
+        # GH 5647
+        dfa = DataFrame(
+            [
+                ["2012-08-02", "L", 10],
+                ["2012-08-02", "J", 15],
+                ["2013-04-06", "L", 20],
+                ["2013-04-06", "J", 25],
+            ],
+            columns=["x", "y", "a"],
+        )
+        dfa["x"] = pd.to_datetime(dfa["x"])
+        dfb = DataFrame(
+            [["2012-08-02", "J", 1], ["2013-04-06", "L", 2]],
+            columns=["x", "y", "z"],
+            index=[2, 4],
+        )
+        dfb["x"] = pd.to_datetime(dfb["x"])
+        result = dfb.join(dfa.set_index(["x", "y"]), on=["x", "y"])
+        expected = DataFrame(
+            [
+                [Timestamp("2012-08-02 00:00:00"), "J", 1, 15],
+                [Timestamp("2013-04-06 00:00:00"), "L", 2, 20],
+            ],
+            index=[2, 4],
+            columns=["x", "y", "z", "a"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_with_categorical_index(self):
+        # GH47812
+        ix = ["a", "b"]
+        id1 = pd.CategoricalIndex(ix, categories=ix)
+        id2 = pd.CategoricalIndex(reversed(ix), categories=reversed(ix))
+
+        df1 = DataFrame({"c1": ix}, index=id1)
+        df2 = DataFrame({"c2": reversed(ix)}, index=id2)
+        result = df1.join(df2)
+        expected = DataFrame(
+            {"c1": ["a", "b"], "c2": ["a", "b"]},
+            index=pd.CategoricalIndex(["a", "b"], categories=["a", "b"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+def _check_join(left, right, result, join_col, how="left", lsuffix="_x", rsuffix="_y"):
+    # some smoke tests
+    for c in join_col:
+        assert result[c].notna().all()
+
+    left_grouped = left.groupby(join_col)
+    right_grouped = right.groupby(join_col)
+
+    for group_key, group in result.groupby(
+        join_col if len(join_col) > 1 else join_col[0]
+    ):
+        l_joined = _restrict_to_columns(group, left.columns, lsuffix)
+        r_joined = _restrict_to_columns(group, right.columns, rsuffix)
+
+        try:
+            lgroup = left_grouped.get_group(group_key)
+        except KeyError as err:
+            if how in ("left", "inner"):
+                raise AssertionError(
+                    f"key {group_key} should not have been in the join"
+                ) from err
+
+            _assert_all_na(l_joined, left.columns, join_col)
+        else:
+            _assert_same_contents(l_joined, lgroup)
+
+        try:
+            rgroup = right_grouped.get_group(group_key)
+        except KeyError as err:
+            if how in ("right", "inner"):
+                raise AssertionError(
+                    f"key {group_key} should not have been in the join"
+                ) from err
+
+            _assert_all_na(r_joined, right.columns, join_col)
+        else:
+            _assert_same_contents(r_joined, rgroup)
+
+
+def _restrict_to_columns(group, columns, suffix):
+    found = [
+        c for c in group.columns if c in columns or c.replace(suffix, "") in columns
+    ]
+
+    # filter
+    group = group.loc[:, found]
+
+    # get rid of suffixes, if any
+    group = group.rename(columns=lambda x: x.replace(suffix, ""))
+
+    # put in the right order...
+    group = group.loc[:, columns]
+
+    return group
+
+
+def _assert_same_contents(join_chunk, source):
+    NA_SENTINEL = -1234567  # drop_duplicates not so NA-friendly...
+
+    jvalues = join_chunk.fillna(NA_SENTINEL).drop_duplicates().values
+    svalues = source.fillna(NA_SENTINEL).drop_duplicates().values
+
+    rows = {tuple(row) for row in jvalues}
+    assert len(rows) == len(source)
+    assert all(tuple(row) in rows for row in svalues)
+
+
+def _assert_all_na(join_chunk, source_columns, join_col):
+    for c in source_columns:
+        if c in join_col:
+            continue
+        assert join_chunk[c].isna().all()
+
+
+def _join_by_hand(a, b, how="left"):
+    join_index = a.index.join(b.index, how=how)
+
+    a_re = a.reindex(join_index)
+    b_re = b.reindex(join_index)
+
+    result_columns = a.columns.append(b.columns)
+
+    for col, s in b_re.items():
+        a_re[col] = s
+    return a_re.reindex(columns=result_columns)
+
+
+def test_join_inner_multiindex_deterministic_order():
+    # GH: 36910
+    left = DataFrame(
+        data={"e": 5},
+        index=MultiIndex.from_tuples([(1, 2, 4)], names=("a", "b", "d")),
+    )
+    right = DataFrame(
+        data={"f": 6}, index=MultiIndex.from_tuples([(2, 3)], names=("b", "c"))
+    )
+    result = left.join(right, how="inner")
+    expected = DataFrame(
+        {"e": [5], "f": [6]},
+        index=MultiIndex.from_tuples([(2, 1, 4, 3)], names=("b", "a", "d", "c")),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("input_col", "output_cols"), [("b", ["a", "b"]), ("a", ["a_x", "a_y"])]
+)
+def test_join_cross(input_col, output_cols):
+    # GH#5401
+    left = DataFrame({"a": [1, 3]})
+    right = DataFrame({input_col: [3, 4]})
+    result = left.join(right, how="cross", lsuffix="_x", rsuffix="_y")
+    expected = DataFrame({output_cols[0]: [1, 1, 3, 3], output_cols[1]: [3, 4, 3, 4]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_join_multiindex_one_level(join_type):
+    # GH#36909
+    left = DataFrame(
+        data={"c": 3}, index=MultiIndex.from_tuples([(1, 2)], names=("a", "b"))
+    )
+    right = DataFrame(data={"d": 4}, index=MultiIndex.from_tuples([(2,)], names=("b",)))
+    result = left.join(right, how=join_type)
+    expected = DataFrame(
+        {"c": [3], "d": [4]},
+        index=MultiIndex.from_tuples([(2, 1)], names=["b", "a"]),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "categories, values",
+    [
+        (["Y", "X"], ["Y", "X", "X"]),
+        ([2, 1], [2, 1, 1]),
+        ([2.5, 1.5], [2.5, 1.5, 1.5]),
+        (
+            [Timestamp("2020-12-31"), Timestamp("2019-12-31")],
+            [Timestamp("2020-12-31"), Timestamp("2019-12-31"), Timestamp("2019-12-31")],
+        ),
+    ],
+)
+def test_join_multiindex_not_alphabetical_categorical(categories, values):
+    # GH#38502
+    left = DataFrame(
+        {
+            "first": ["A", "A"],
+            "second": Categorical(categories, categories=categories),
+            "value": [1, 2],
+        }
+    ).set_index(["first", "second"])
+    right = DataFrame(
+        {
+            "first": ["A", "A", "B"],
+            "second": Categorical(values, categories=categories),
+            "value": [3, 4, 5],
+        }
+    ).set_index(["first", "second"])
+    result = left.join(right, lsuffix="_left", rsuffix="_right")
+
+    expected = DataFrame(
+        {
+            "first": ["A", "A"],
+            "second": Categorical(categories, categories=categories),
+            "value_left": [1, 2],
+            "value_right": [3, 4],
+        }
+    ).set_index(["first", "second"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "left_empty, how, exp",
+    [
+        (False, "left", "left"),
+        (False, "right", "empty"),
+        (False, "inner", "empty"),
+        (False, "outer", "left"),
+        (False, "cross", "empty"),
+        (True, "left", "empty"),
+        (True, "right", "right"),
+        (True, "inner", "empty"),
+        (True, "outer", "right"),
+        (True, "cross", "empty"),
+    ],
+)
+def test_join_empty(left_empty, how, exp):
+    left = DataFrame({"A": [2, 1], "B": [3, 4]}, dtype="int64").set_index("A")
+    right = DataFrame({"A": [1], "C": [5]}, dtype="int64").set_index("A")
+
+    if left_empty:
+        left = left.head(0)
+    else:
+        right = right.head(0)
+
+    result = left.join(right, how=how)
+
+    if exp == "left":
+        expected = DataFrame({"A": [2, 1], "B": [3, 4], "C": [np.nan, np.nan]})
+        expected = expected.set_index("A")
+    elif exp == "right":
+        expected = DataFrame({"B": [np.nan], "A": [1], "C": [5]})
+        expected = expected.set_index("A")
+    elif exp == "empty":
+        expected = DataFrame(columns=["B", "C"], dtype="int64")
+        if how != "cross":
+            expected = expected.rename_axis("A")
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "how, values",
+    [
+        ("inner", [0, 1, 2]),
+        ("outer", [0, 1, 2]),
+        ("left", [0, 1, 2]),
+        ("right", [0, 2, 1]),
+    ],
+)
+def test_join_multiindex_categorical_output_index_dtype(how, values):
+    # GH#50906
+    df1 = DataFrame(
+        {
+            "a": Categorical([0, 1, 2]),
+            "b": Categorical([0, 1, 2]),
+            "c": [0, 1, 2],
+        }
+    ).set_index(["a", "b"])
+
+    df2 = DataFrame(
+        {
+            "a": Categorical([0, 2, 1]),
+            "b": Categorical([0, 2, 1]),
+            "d": [0, 2, 1],
+        }
+    ).set_index(["a", "b"])
+
+    expected = DataFrame(
+        {
+            "a": Categorical(values),
+            "b": Categorical(values),
+            "c": values,
+            "d": values,
+        }
+    ).set_index(["a", "b"])
+
+    result = df1.join(df2, how=how)
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge.py
new file mode 100644
index 0000000000000000000000000000000000000000..6868f7344c153a51af8fe18aaaa07394d860441d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge.py
@@ -0,0 +1,2887 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+import re
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_object_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    IntervalIndex,
+    MultiIndex,
+    PeriodIndex,
+    RangeIndex,
+    Series,
+    TimedeltaIndex,
+)
+import pandas._testing as tm
+from pandas.api.types import CategoricalDtype as CDT
+from pandas.core.reshape.concat import concat
+from pandas.core.reshape.merge import (
+    MergeError,
+    merge,
+)
+
+
+def get_test_data(ngroups=8, n=50):
+    unique_groups = list(range(ngroups))
+    arr = np.asarray(np.tile(unique_groups, n // ngroups))
+
+    if len(arr) < n:
+        arr = np.asarray(list(arr) + unique_groups[: n - len(arr)])
+
+    np.random.default_rng(2).shuffle(arr)
+    return arr
+
+
+def get_series():
+    return [
+        Series([1], dtype="int64"),
+        Series([1], dtype="Int64"),
+        Series([1.23]),
+        Series(["foo"]),
+        Series([True]),
+        Series([pd.Timestamp("2018-01-01")]),
+        Series([pd.Timestamp("2018-01-01", tz="US/Eastern")]),
+    ]
+
+
+def get_series_na():
+    return [
+        Series([np.nan], dtype="Int64"),
+        Series([np.nan], dtype="float"),
+        Series([np.nan], dtype="object"),
+        Series([pd.NaT]),
+    ]
+
+
+@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
+def series_of_dtype(request):
+    """
+    A parametrized fixture returning a variety of Series of different
+    dtypes
+    """
+    return request.param
+
+
+@pytest.fixture(params=get_series(), ids=lambda x: x.dtype.name)
+def series_of_dtype2(request):
+    """
+    A duplicate of the series_of_dtype fixture, so that it can be used
+    twice by a single function
+    """
+    return request.param
+
+
+@pytest.fixture(params=get_series_na(), ids=lambda x: x.dtype.name)
+def series_of_dtype_all_na(request):
+    """
+    A parametrized fixture returning a variety of Series with all NA
+    values
+    """
+    return request.param
+
+
+@pytest.fixture
+def dfs_for_indicator():
+    df1 = DataFrame({"col1": [0, 1], "col_conflict": [1, 2], "col_left": ["a", "b"]})
+    df2 = DataFrame(
+        {
+            "col1": [1, 2, 3, 4, 5],
+            "col_conflict": [1, 2, 3, 4, 5],
+            "col_right": [2, 2, 2, 2, 2],
+        }
+    )
+    return df1, df2
+
+
+class TestMerge:
+    @pytest.fixture
+    def df(self):
+        df = DataFrame(
+            {
+                "key1": get_test_data(),
+                "key2": get_test_data(),
+                "data1": np.random.default_rng(2).standard_normal(50),
+                "data2": np.random.default_rng(2).standard_normal(50),
+            }
+        )
+
+        # exclude a couple keys for fun
+        df = df[df["key2"] > 1]
+        return df
+
+    @pytest.fixture
+    def df2(self):
+        return DataFrame(
+            {
+                "key1": get_test_data(n=10),
+                "key2": get_test_data(ngroups=4, n=10),
+                "value": np.random.default_rng(2).standard_normal(10),
+            }
+        )
+
+    @pytest.fixture
+    def left(self):
+        return DataFrame(
+            {
+                "key": ["a", "b", "c", "d", "e", "e", "a"],
+                "v1": np.random.default_rng(2).standard_normal(7),
+            }
+        )
+
+    @pytest.fixture
+    def right(self):
+        return DataFrame(
+            {"v2": np.random.default_rng(2).standard_normal(4)},
+            index=["d", "b", "c", "a"],
+        )
+
+    def test_merge_inner_join_empty(self):
+        # GH 15328
+        df_empty = DataFrame()
+        df_a = DataFrame({"a": [1, 2]}, index=[0, 1], dtype="int64")
+        result = merge(df_empty, df_a, left_index=True, right_index=True)
+        expected = DataFrame({"a": []}, dtype="int64")
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_common(self, df, df2):
+        joined = merge(df, df2)
+        exp = merge(df, df2, on=["key1", "key2"])
+        tm.assert_frame_equal(joined, exp)
+
+    def test_merge_non_string_columns(self):
+        # https://github.com/pandas-dev/pandas/issues/17962
+        # Checks that method runs for non string column names
+        left = DataFrame(
+            {0: [1, 0, 1, 0], 1: [0, 1, 0, 0], 2: [0, 0, 2, 0], 3: [1, 0, 0, 3]}
+        )
+
+        right = left.astype(float)
+        expected = left
+        result = merge(left, right)
+        tm.assert_frame_equal(expected, result)
+
+    def test_merge_index_as_on_arg(self, df, df2):
+        # GH14355
+
+        left = df.set_index("key1")
+        right = df2.set_index("key1")
+        result = merge(left, right, on="key1")
+        expected = merge(df, df2, on="key1").set_index("key1")
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_index_singlekey_right_vs_left(self):
+        left = DataFrame(
+            {
+                "key": ["a", "b", "c", "d", "e", "e", "a"],
+                "v1": np.random.default_rng(2).standard_normal(7),
+            }
+        )
+        right = DataFrame(
+            {"v2": np.random.default_rng(2).standard_normal(4)},
+            index=["d", "b", "c", "a"],
+        )
+
+        merged1 = merge(
+            left, right, left_on="key", right_index=True, how="left", sort=False
+        )
+        merged2 = merge(
+            right, left, right_on="key", left_index=True, how="right", sort=False
+        )
+        tm.assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
+
+        merged1 = merge(
+            left, right, left_on="key", right_index=True, how="left", sort=True
+        )
+        merged2 = merge(
+            right, left, right_on="key", left_index=True, how="right", sort=True
+        )
+        tm.assert_frame_equal(merged1, merged2.loc[:, merged1.columns])
+
+    def test_merge_index_singlekey_inner(self):
+        left = DataFrame(
+            {
+                "key": ["a", "b", "c", "d", "e", "e", "a"],
+                "v1": np.random.default_rng(2).standard_normal(7),
+            }
+        )
+        right = DataFrame(
+            {"v2": np.random.default_rng(2).standard_normal(4)},
+            index=["d", "b", "c", "a"],
+        )
+
+        # inner join
+        result = merge(left, right, left_on="key", right_index=True, how="inner")
+        expected = left.join(right, on="key").loc[result.index]
+        tm.assert_frame_equal(result, expected)
+
+        result = merge(right, left, right_on="key", left_index=True, how="inner")
+        expected = left.join(right, on="key").loc[result.index]
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
+
+    def test_merge_misspecified(self, df, df2, left, right):
+        msg = "Must pass right_on or right_index=True"
+        with pytest.raises(pd.errors.MergeError, match=msg):
+            merge(left, right, left_index=True)
+        msg = "Must pass left_on or left_index=True"
+        with pytest.raises(pd.errors.MergeError, match=msg):
+            merge(left, right, right_index=True)
+
+        msg = (
+            'Can only pass argument "on" OR "left_on" and "right_on", not '
+            "a combination of both"
+        )
+        with pytest.raises(pd.errors.MergeError, match=msg):
+            merge(left, left, left_on="key", on="key")
+
+        msg = r"len\(right_on\) must equal len\(left_on\)"
+        with pytest.raises(ValueError, match=msg):
+            merge(df, df2, left_on=["key1"], right_on=["key1", "key2"])
+
+    def test_index_and_on_parameters_confusion(self, df, df2):
+        msg = "right_index parameter must be of type bool, not <class 'list'>"
+        with pytest.raises(ValueError, match=msg):
+            merge(
+                df,
+                df2,
+                how="left",
+                left_index=False,
+                right_index=["key1", "key2"],
+            )
+        msg = "left_index parameter must be of type bool, not <class 'list'>"
+        with pytest.raises(ValueError, match=msg):
+            merge(
+                df,
+                df2,
+                how="left",
+                left_index=["key1", "key2"],
+                right_index=False,
+            )
+        with pytest.raises(ValueError, match=msg):
+            merge(
+                df,
+                df2,
+                how="left",
+                left_index=["key1", "key2"],
+                right_index=["key1", "key2"],
+            )
+
+    def test_merge_overlap(self, left):
+        merged = merge(left, left, on="key")
+        exp_len = (left["key"].value_counts() ** 2).sum()
+        assert len(merged) == exp_len
+        assert "v1_x" in merged
+        assert "v1_y" in merged
+
+    def test_merge_different_column_key_names(self):
+        left = DataFrame({"lkey": ["foo", "bar", "baz", "foo"], "value": [1, 2, 3, 4]})
+        right = DataFrame({"rkey": ["foo", "bar", "qux", "foo"], "value": [5, 6, 7, 8]})
+
+        merged = left.merge(
+            right, left_on="lkey", right_on="rkey", how="outer", sort=True
+        )
+
+        exp = Series(["bar", "baz", "foo", "foo", "foo", "foo", np.nan], name="lkey")
+        tm.assert_series_equal(merged["lkey"], exp)
+
+        exp = Series(["bar", np.nan, "foo", "foo", "foo", "foo", "qux"], name="rkey")
+        tm.assert_series_equal(merged["rkey"], exp)
+
+        exp = Series([2, 3, 1, 1, 4, 4, np.nan], name="value_x")
+        tm.assert_series_equal(merged["value_x"], exp)
+
+        exp = Series([6, np.nan, 5, 8, 5, 8, 7], name="value_y")
+        tm.assert_series_equal(merged["value_y"], exp)
+
+    def test_merge_copy(self):
+        left = DataFrame({"a": 0, "b": 1}, index=range(10))
+        right = DataFrame({"c": "foo", "d": "bar"}, index=range(10))
+
+        merged = merge(left, right, left_index=True, right_index=True, copy=True)
+
+        merged["a"] = 6
+        assert (left["a"] == 0).all()
+
+        merged["d"] = "peekaboo"
+        assert (right["d"] == "bar").all()
+
+    def test_merge_nocopy(self, using_array_manager):
+        left = DataFrame({"a": 0, "b": 1}, index=range(10))
+        right = DataFrame({"c": "foo", "d": "bar"}, index=range(10))
+
+        merged = merge(left, right, left_index=True, right_index=True, copy=False)
+
+        assert np.shares_memory(merged["a"]._values, left["a"]._values)
+        assert np.shares_memory(merged["d"]._values, right["d"]._values)
+
+    def test_intelligently_handle_join_key(self):
+        # #733, be a bit more 1337 about not returning unconsolidated DataFrame
+
+        left = DataFrame(
+            {"key": [1, 1, 2, 2, 3], "value": list(range(5))}, columns=["value", "key"]
+        )
+        right = DataFrame({"key": [1, 1, 2, 3, 4, 5], "rvalue": list(range(6))})
+
+        joined = merge(left, right, on="key", how="outer")
+        expected = DataFrame(
+            {
+                "key": [1, 1, 1, 1, 2, 2, 3, 4, 5],
+                "value": np.array([0, 0, 1, 1, 2, 3, 4, np.nan, np.nan]),
+                "rvalue": [0, 1, 0, 1, 2, 2, 3, 4, 5],
+            },
+            columns=["value", "key", "rvalue"],
+        )
+        tm.assert_frame_equal(joined, expected)
+
+    def test_merge_join_key_dtype_cast(self):
+        # #8596
+
+        df1 = DataFrame({"key": [1], "v1": [10]})
+        df2 = DataFrame({"key": [2], "v1": [20]})
+        df = merge(df1, df2, how="outer")
+        assert df["key"].dtype == "int64"
+
+        df1 = DataFrame({"key": [True], "v1": [1]})
+        df2 = DataFrame({"key": [False], "v1": [0]})
+        df = merge(df1, df2, how="outer")
+
+        # GH13169
+        # GH#40073
+        assert df["key"].dtype == "bool"
+
+        df1 = DataFrame({"val": [1]})
+        df2 = DataFrame({"val": [2]})
+        lkey = np.array([1])
+        rkey = np.array([2])
+        df = merge(df1, df2, left_on=lkey, right_on=rkey, how="outer")
+        assert df["key_0"].dtype == np.dtype(int)
+
+    def test_handle_join_key_pass_array(self):
+        left = DataFrame(
+            {"key": [1, 1, 2, 2, 3], "value": np.arange(5)},
+            columns=["value", "key"],
+            dtype="int64",
+        )
+        right = DataFrame({"rvalue": np.arange(6)}, dtype="int64")
+        key = np.array([1, 1, 2, 3, 4, 5], dtype="int64")
+
+        merged = merge(left, right, left_on="key", right_on=key, how="outer")
+        merged2 = merge(right, left, left_on=key, right_on="key", how="outer")
+
+        tm.assert_series_equal(merged["key"], merged2["key"])
+        assert merged["key"].notna().all()
+        assert merged2["key"].notna().all()
+
+        left = DataFrame({"value": np.arange(5)}, columns=["value"])
+        right = DataFrame({"rvalue": np.arange(6)})
+        lkey = np.array([1, 1, 2, 2, 3])
+        rkey = np.array([1, 1, 2, 3, 4, 5])
+
+        merged = merge(left, right, left_on=lkey, right_on=rkey, how="outer")
+        expected = Series([1, 1, 1, 1, 2, 2, 3, 4, 5], dtype=int, name="key_0")
+        tm.assert_series_equal(merged["key_0"], expected)
+
+        left = DataFrame({"value": np.arange(3)})
+        right = DataFrame({"rvalue": np.arange(6)})
+
+        key = np.array([0, 1, 1, 2, 2, 3], dtype=np.int64)
+        merged = merge(left, right, left_index=True, right_on=key, how="outer")
+        tm.assert_series_equal(merged["key_0"], Series(key, name="key_0"))
+
+    def test_no_overlap_more_informative_error(self):
+        dt = datetime.now()
+        df1 = DataFrame({"x": ["a"]}, index=[dt])
+
+        df2 = DataFrame({"y": ["b", "c"]}, index=[dt, dt])
+
+        msg = (
+            "No common columns to perform merge on. "
+            f"Merge options: left_on={None}, right_on={None}, "
+            f"left_index={False}, right_index={False}"
+        )
+
+        with pytest.raises(MergeError, match=msg):
+            merge(df1, df2)
+
+    def test_merge_non_unique_indexes(self):
+        dt = datetime(2012, 5, 1)
+        dt2 = datetime(2012, 5, 2)
+        dt3 = datetime(2012, 5, 3)
+        dt4 = datetime(2012, 5, 4)
+
+        df1 = DataFrame({"x": ["a"]}, index=[dt])
+        df2 = DataFrame({"y": ["b", "c"]}, index=[dt, dt])
+        _check_merge(df1, df2)
+
+        # Not monotonic
+        df1 = DataFrame({"x": ["a", "b", "q"]}, index=[dt2, dt, dt4])
+        df2 = DataFrame(
+            {"y": ["c", "d", "e", "f", "g", "h"]}, index=[dt3, dt3, dt2, dt2, dt, dt]
+        )
+        _check_merge(df1, df2)
+
+        df1 = DataFrame({"x": ["a", "b"]}, index=[dt, dt])
+        df2 = DataFrame({"y": ["c", "d"]}, index=[dt, dt])
+        _check_merge(df1, df2)
+
+    def test_merge_non_unique_index_many_to_many(self):
+        dt = datetime(2012, 5, 1)
+        dt2 = datetime(2012, 5, 2)
+        dt3 = datetime(2012, 5, 3)
+        df1 = DataFrame({"x": ["a", "b", "c", "d"]}, index=[dt2, dt2, dt, dt])
+        df2 = DataFrame(
+            {"y": ["e", "f", "g", " h", "i"]}, index=[dt2, dt2, dt3, dt, dt]
+        )
+        _check_merge(df1, df2)
+
+    def test_left_merge_empty_dataframe(self):
+        left = DataFrame({"key": [1], "value": [2]})
+        right = DataFrame({"key": []})
+
+        result = merge(left, right, on="key", how="left")
+        tm.assert_frame_equal(result, left)
+
+        result = merge(right, left, on="key", how="right")
+        tm.assert_frame_equal(result, left)
+
+    @pytest.mark.parametrize("how", ["inner", "left", "right", "outer"])
+    def test_merge_empty_dataframe(self, index, how):
+        # GH52777
+        left = DataFrame([], index=index[:0])
+        right = left.copy()
+
+        result = left.join(right, how=how)
+        tm.assert_frame_equal(result, left)
+
+    @pytest.mark.parametrize(
+        "kwarg",
+        [
+            {"left_index": True, "right_index": True},
+            {"left_index": True, "right_on": "x"},
+            {"left_on": "a", "right_index": True},
+            {"left_on": "a", "right_on": "x"},
+        ],
+    )
+    def test_merge_left_empty_right_empty(self, join_type, kwarg):
+        # GH 10824
+        left = DataFrame(columns=["a", "b", "c"])
+        right = DataFrame(columns=["x", "y", "z"])
+
+        exp_in = DataFrame(columns=["a", "b", "c", "x", "y", "z"], dtype=object)
+
+        result = merge(left, right, how=join_type, **kwarg)
+        tm.assert_frame_equal(result, exp_in)
+
+    def test_merge_left_empty_right_notempty(self):
+        # GH 10824
+        left = DataFrame(columns=["a", "b", "c"])
+        right = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=["x", "y", "z"])
+
+        exp_out = DataFrame(
+            {
+                "a": np.array([np.nan] * 3, dtype=object),
+                "b": np.array([np.nan] * 3, dtype=object),
+                "c": np.array([np.nan] * 3, dtype=object),
+                "x": [1, 4, 7],
+                "y": [2, 5, 8],
+                "z": [3, 6, 9],
+            },
+            columns=["a", "b", "c", "x", "y", "z"],
+        )
+        exp_in = exp_out[0:0]  # make empty DataFrame keeping dtype
+
+        def check1(exp, kwarg):
+            result = merge(left, right, how="inner", **kwarg)
+            tm.assert_frame_equal(result, exp)
+            result = merge(left, right, how="left", **kwarg)
+            tm.assert_frame_equal(result, exp)
+
+        def check2(exp, kwarg):
+            result = merge(left, right, how="right", **kwarg)
+            tm.assert_frame_equal(result, exp)
+            result = merge(left, right, how="outer", **kwarg)
+            tm.assert_frame_equal(result, exp)
+
+        for kwarg in [
+            {"left_index": True, "right_index": True},
+            {"left_index": True, "right_on": "x"},
+        ]:
+            check1(exp_in, kwarg)
+            check2(exp_out, kwarg)
+
+        kwarg = {"left_on": "a", "right_index": True}
+        check1(exp_in, kwarg)
+        exp_out["a"] = [0, 1, 2]
+        check2(exp_out, kwarg)
+
+        kwarg = {"left_on": "a", "right_on": "x"}
+        check1(exp_in, kwarg)
+        exp_out["a"] = np.array([np.nan] * 3, dtype=object)
+        check2(exp_out, kwarg)
+
+    def test_merge_left_notempty_right_empty(self):
+        # GH 10824
+        left = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=["a", "b", "c"])
+        right = DataFrame(columns=["x", "y", "z"])
+
+        exp_out = DataFrame(
+            {
+                "a": [1, 4, 7],
+                "b": [2, 5, 8],
+                "c": [3, 6, 9],
+                "x": np.array([np.nan] * 3, dtype=object),
+                "y": np.array([np.nan] * 3, dtype=object),
+                "z": np.array([np.nan] * 3, dtype=object),
+            },
+            columns=["a", "b", "c", "x", "y", "z"],
+        )
+        exp_in = exp_out[0:0]  # make empty DataFrame keeping dtype
+        # result will have object dtype
+        exp_in.index = exp_in.index.astype(object)
+
+        def check1(exp, kwarg):
+            result = merge(left, right, how="inner", **kwarg)
+            tm.assert_frame_equal(result, exp)
+            result = merge(left, right, how="right", **kwarg)
+            tm.assert_frame_equal(result, exp)
+
+        def check2(exp, kwarg):
+            result = merge(left, right, how="left", **kwarg)
+            tm.assert_frame_equal(result, exp)
+            result = merge(left, right, how="outer", **kwarg)
+            tm.assert_frame_equal(result, exp)
+
+            # TODO: should the next loop be un-indented? doing so breaks this test
+            for kwarg in [
+                {"left_index": True, "right_index": True},
+                {"left_index": True, "right_on": "x"},
+                {"left_on": "a", "right_index": True},
+                {"left_on": "a", "right_on": "x"},
+            ]:
+                check1(exp_in, kwarg)
+                check2(exp_out, kwarg)
+
+    def test_merge_empty_frame(self, series_of_dtype, series_of_dtype2):
+        # GH 25183
+        df = DataFrame(
+            {"key": series_of_dtype, "value": series_of_dtype2},
+            columns=["key", "value"],
+        )
+        df_empty = df[:0]
+        expected = DataFrame(
+            {
+                "value_x": Series(dtype=df.dtypes["value"]),
+                "key": Series(dtype=df.dtypes["key"]),
+                "value_y": Series(dtype=df.dtypes["value"]),
+            },
+            columns=["value_x", "key", "value_y"],
+        )
+        actual = df_empty.merge(df, on="key")
+        tm.assert_frame_equal(actual, expected)
+
+    def test_merge_all_na_column(self, series_of_dtype, series_of_dtype_all_na):
+        # GH 25183
+        df_left = DataFrame(
+            {"key": series_of_dtype, "value": series_of_dtype_all_na},
+            columns=["key", "value"],
+        )
+        df_right = DataFrame(
+            {"key": series_of_dtype, "value": series_of_dtype_all_na},
+            columns=["key", "value"],
+        )
+        expected = DataFrame(
+            {
+                "key": series_of_dtype,
+                "value_x": series_of_dtype_all_na,
+                "value_y": series_of_dtype_all_na,
+            },
+            columns=["key", "value_x", "value_y"],
+        )
+        actual = df_left.merge(df_right, on="key")
+        tm.assert_frame_equal(actual, expected)
+
+    def test_merge_nosort(self):
+        # GH#2098
+
+        d = {
+            "var1": np.random.default_rng(2).integers(0, 10, size=10),
+            "var2": np.random.default_rng(2).integers(0, 10, size=10),
+            "var3": [
+                datetime(2012, 1, 12),
+                datetime(2011, 2, 4),
+                datetime(2010, 2, 3),
+                datetime(2012, 1, 12),
+                datetime(2011, 2, 4),
+                datetime(2012, 4, 3),
+                datetime(2012, 3, 4),
+                datetime(2008, 5, 1),
+                datetime(2010, 2, 3),
+                datetime(2012, 2, 3),
+            ],
+        }
+        df = DataFrame.from_dict(d)
+        var3 = df.var3.unique()
+        var3 = np.sort(var3)
+        new = DataFrame.from_dict(
+            {"var3": var3, "var8": np.random.default_rng(2).random(7)}
+        )
+
+        result = df.merge(new, on="var3", sort=False)
+        exp = merge(df, new, on="var3", sort=False)
+        tm.assert_frame_equal(result, exp)
+
+        assert (df.var3.unique() == result.var3.unique()).all()
+
+    @pytest.mark.parametrize(
+        ("sort", "values"), [(False, [1, 1, 0, 1, 1]), (True, [0, 1, 1, 1, 1])]
+    )
+    @pytest.mark.parametrize("how", ["left", "right"])
+    def test_merge_same_order_left_right(self, sort, values, how):
+        # GH#35382
+        df = DataFrame({"a": [1, 0, 1]})
+
+        result = df.merge(df, on="a", how=how, sort=sort)
+        expected = DataFrame(values, columns=["a"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_nan_right(self):
+        df1 = DataFrame({"i1": [0, 1], "i2": [0, 1]})
+        df2 = DataFrame({"i1": [0], "i3": [0]})
+        result = df1.join(df2, on="i1", rsuffix="_")
+        expected = (
+            DataFrame(
+                {
+                    "i1": {0: 0.0, 1: 1},
+                    "i2": {0: 0, 1: 1},
+                    "i1_": {0: 0, 1: np.nan},
+                    "i3": {0: 0.0, 1: np.nan},
+                    None: {0: 0, 1: 0},
+                }
+            )
+            .set_index(None)
+            .reset_index()[["i1", "i2", "i1_", "i3"]]
+        )
+        tm.assert_frame_equal(result, expected, check_dtype=False)
+
+    def test_merge_nan_right2(self):
+        df1 = DataFrame({"i1": [0, 1], "i2": [0.5, 1.5]})
+        df2 = DataFrame({"i1": [0], "i3": [0.7]})
+        result = df1.join(df2, rsuffix="_", on="i1")
+        expected = DataFrame(
+            {
+                "i1": {0: 0, 1: 1},
+                "i1_": {0: 0.0, 1: np.nan},
+                "i2": {0: 0.5, 1: 1.5},
+                "i3": {0: 0.69999999999999996, 1: np.nan},
+            }
+        )[["i1", "i2", "i1_", "i3"]]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.filterwarnings(
+        "ignore:Passing a BlockManager|Passing a SingleBlockManager:DeprecationWarning"
+    )
+    def test_merge_type(self, df, df2):
+        class NotADataFrame(DataFrame):
+            @property
+            def _constructor(self):
+                return NotADataFrame
+
+        nad = NotADataFrame(df)
+        result = nad.merge(df2, on="key1")
+
+        assert isinstance(result, NotADataFrame)
+
+    def test_join_append_timedeltas(self, using_array_manager):
+        # timedelta64 issues with join/merge
+        # GH 5695
+
+        d = DataFrame.from_dict(
+            {"d": [datetime(2013, 11, 5, 5, 56)], "t": [timedelta(0, 22500)]}
+        )
+        df = DataFrame(columns=list("dt"))
+        msg = "The behavior of DataFrame concatenation with empty or all-NA entries"
+        warn = FutureWarning
+        if using_array_manager:
+            warn = None
+        with tm.assert_produces_warning(warn, match=msg):
+            df = concat([df, d], ignore_index=True)
+            result = concat([df, d], ignore_index=True)
+        expected = DataFrame(
+            {
+                "d": [datetime(2013, 11, 5, 5, 56), datetime(2013, 11, 5, 5, 56)],
+                "t": [timedelta(0, 22500), timedelta(0, 22500)],
+            }
+        )
+        if using_array_manager:
+            # TODO(ArrayManager) decide on exact casting rules in concat
+            expected = expected.astype(object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_append_timedeltas2(self):
+        # timedelta64 issues with join/merge
+        # GH 5695
+        td = np.timedelta64(300000000)
+        lhs = DataFrame(Series([td, td], index=["A", "B"]))
+        rhs = DataFrame(Series([td], index=["A"]))
+
+        result = lhs.join(rhs, rsuffix="r", how="left")
+        expected = DataFrame(
+            {
+                "0": Series([td, td], index=list("AB")),
+                "0r": Series([td, pd.NaT], index=list("AB")),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("unit", ["D", "h", "m", "s", "ms", "us", "ns"])
+    def test_other_datetime_unit(self, unit):
+        # GH 13389
+        df1 = DataFrame({"entity_id": [101, 102]})
+        ser = Series([None, None], index=[101, 102], name="days")
+
+        dtype = f"datetime64[{unit}]"
+
+        if unit in ["D", "h", "m"]:
+            # not supported so we cast to the nearest supported unit, seconds
+            exp_dtype = "datetime64[s]"
+        else:
+            exp_dtype = dtype
+        df2 = ser.astype(exp_dtype).to_frame("days")
+        assert df2["days"].dtype == exp_dtype
+
+        result = df1.merge(df2, left_on="entity_id", right_index=True)
+
+        days = np.array(["nat", "nat"], dtype=exp_dtype)
+        days = pd.core.arrays.DatetimeArray._simple_new(days, dtype=days.dtype)
+        exp = DataFrame(
+            {
+                "entity_id": [101, 102],
+                "days": days,
+            },
+            columns=["entity_id", "days"],
+        )
+        assert exp["days"].dtype == exp_dtype
+        tm.assert_frame_equal(result, exp)
+
+    @pytest.mark.parametrize("unit", ["D", "h", "m", "s", "ms", "us", "ns"])
+    def test_other_timedelta_unit(self, unit):
+        # GH 13389
+        df1 = DataFrame({"entity_id": [101, 102]})
+        ser = Series([None, None], index=[101, 102], name="days")
+
+        dtype = f"m8[{unit}]"
+        if unit in ["D", "h", "m"]:
+            # We cannot astype, instead do nearest supported unit, i.e. "s"
+            msg = "Supported resolutions are 's', 'ms', 'us', 'ns'"
+            with pytest.raises(ValueError, match=msg):
+                ser.astype(dtype)
+
+            df2 = ser.astype("m8[s]").to_frame("days")
+        else:
+            df2 = ser.astype(dtype).to_frame("days")
+            assert df2["days"].dtype == dtype
+
+        result = df1.merge(df2, left_on="entity_id", right_index=True)
+
+        exp = DataFrame(
+            {"entity_id": [101, 102], "days": np.array(["nat", "nat"], dtype=dtype)},
+            columns=["entity_id", "days"],
+        )
+        tm.assert_frame_equal(result, exp)
+
+    def test_overlapping_columns_error_message(self):
+        df = DataFrame({"key": [1, 2, 3], "v1": [4, 5, 6], "v2": [7, 8, 9]})
+        df2 = DataFrame({"key": [1, 2, 3], "v1": [4, 5, 6], "v2": [7, 8, 9]})
+
+        df.columns = ["key", "foo", "foo"]
+        df2.columns = ["key", "bar", "bar"]
+        expected = DataFrame(
+            {
+                "key": [1, 2, 3],
+                "v1": [4, 5, 6],
+                "v2": [7, 8, 9],
+                "v3": [4, 5, 6],
+                "v4": [7, 8, 9],
+            }
+        )
+        expected.columns = ["key", "foo", "foo", "bar", "bar"]
+        tm.assert_frame_equal(merge(df, df2), expected)
+
+        # #2649, #10639
+        df2.columns = ["key1", "foo", "foo"]
+        msg = r"Data columns not unique: Index\(\['foo'\], dtype='object'\)"
+        with pytest.raises(MergeError, match=msg):
+            merge(df, df2)
+
+    def test_merge_on_datetime64tz(self):
+        # GH11405
+        left = DataFrame(
+            {
+                "key": pd.date_range("20151010", periods=2, tz="US/Eastern"),
+                "value": [1, 2],
+            }
+        )
+        right = DataFrame(
+            {
+                "key": pd.date_range("20151011", periods=3, tz="US/Eastern"),
+                "value": [1, 2, 3],
+            }
+        )
+
+        expected = DataFrame(
+            {
+                "key": pd.date_range("20151010", periods=4, tz="US/Eastern"),
+                "value_x": [1, 2, np.nan, np.nan],
+                "value_y": [np.nan, 1, 2, 3],
+            }
+        )
+        result = merge(left, right, on="key", how="outer")
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_datetime64tz_values(self):
+        left = DataFrame(
+            {
+                "key": [1, 2],
+                "value": pd.date_range("20151010", periods=2, tz="US/Eastern"),
+            }
+        )
+        right = DataFrame(
+            {
+                "key": [2, 3],
+                "value": pd.date_range("20151011", periods=2, tz="US/Eastern"),
+            }
+        )
+        expected = DataFrame(
+            {
+                "key": [1, 2, 3],
+                "value_x": list(pd.date_range("20151010", periods=2, tz="US/Eastern"))
+                + [pd.NaT],
+                "value_y": [pd.NaT]
+                + list(pd.date_range("20151011", periods=2, tz="US/Eastern")),
+            }
+        )
+        result = merge(left, right, on="key", how="outer")
+        tm.assert_frame_equal(result, expected)
+        assert result["value_x"].dtype == "datetime64[ns, US/Eastern]"
+        assert result["value_y"].dtype == "datetime64[ns, US/Eastern]"
+
+    def test_merge_on_datetime64tz_empty(self):
+        # https://github.com/pandas-dev/pandas/issues/25014
+        dtz = pd.DatetimeTZDtype(tz="UTC")
+        right = DataFrame(
+            {
+                "date": [pd.Timestamp("2018", tz=dtz.tz)],
+                "value": [4.0],
+                "date2": [pd.Timestamp("2019", tz=dtz.tz)],
+            },
+            columns=["date", "value", "date2"],
+        )
+        left = right[:0]
+        result = left.merge(right, on="date")
+        expected = DataFrame(
+            {
+                "value_x": Series(dtype=float),
+                "date2_x": Series(dtype=dtz),
+                "date": Series(dtype=dtz),
+                "value_y": Series(dtype=float),
+                "date2_y": Series(dtype=dtz),
+            },
+            columns=["value_x", "date2_x", "date", "value_y", "date2_y"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_datetime64tz_with_dst_transition(self):
+        # GH 18885
+        df1 = DataFrame(
+            pd.date_range("2017-10-29 01:00", periods=4, freq="H", tz="Europe/Madrid"),
+            columns=["date"],
+        )
+        df1["value"] = 1
+        df2 = DataFrame(
+            {
+                "date": pd.to_datetime(
+                    [
+                        "2017-10-29 03:00:00",
+                        "2017-10-29 04:00:00",
+                        "2017-10-29 05:00:00",
+                    ]
+                ),
+                "value": 2,
+            }
+        )
+        df2["date"] = df2["date"].dt.tz_localize("UTC").dt.tz_convert("Europe/Madrid")
+        result = merge(df1, df2, how="outer", on="date")
+        expected = DataFrame(
+            {
+                "date": pd.date_range(
+                    "2017-10-29 01:00", periods=7, freq="H", tz="Europe/Madrid"
+                ),
+                "value_x": [1] * 4 + [np.nan] * 3,
+                "value_y": [np.nan] * 4 + [2] * 3,
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_non_unique_period_index(self):
+        # GH #16871
+        index = pd.period_range("2016-01-01", periods=16, freq="M")
+        df = DataFrame(list(range(len(index))), index=index, columns=["pnum"])
+        df2 = concat([df, df])
+        result = df.merge(df2, left_index=True, right_index=True, how="inner")
+        expected = DataFrame(
+            np.tile(np.arange(16, dtype=np.int64).repeat(2).reshape(-1, 1), 2),
+            columns=["pnum_x", "pnum_y"],
+            index=df2.sort_index().index,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_on_periods(self):
+        left = DataFrame(
+            {"key": pd.period_range("20151010", periods=2, freq="D"), "value": [1, 2]}
+        )
+        right = DataFrame(
+            {
+                "key": pd.period_range("20151011", periods=3, freq="D"),
+                "value": [1, 2, 3],
+            }
+        )
+
+        expected = DataFrame(
+            {
+                "key": pd.period_range("20151010", periods=4, freq="D"),
+                "value_x": [1, 2, np.nan, np.nan],
+                "value_y": [np.nan, 1, 2, 3],
+            }
+        )
+        result = merge(left, right, on="key", how="outer")
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_period_values(self):
+        left = DataFrame(
+            {"key": [1, 2], "value": pd.period_range("20151010", periods=2, freq="D")}
+        )
+        right = DataFrame(
+            {"key": [2, 3], "value": pd.period_range("20151011", periods=2, freq="D")}
+        )
+
+        exp_x = pd.period_range("20151010", periods=2, freq="D")
+        exp_y = pd.period_range("20151011", periods=2, freq="D")
+        expected = DataFrame(
+            {
+                "key": [1, 2, 3],
+                "value_x": list(exp_x) + [pd.NaT],
+                "value_y": [pd.NaT] + list(exp_y),
+            }
+        )
+        result = merge(left, right, on="key", how="outer")
+        tm.assert_frame_equal(result, expected)
+        assert result["value_x"].dtype == "Period[D]"
+        assert result["value_y"].dtype == "Period[D]"
+
+    def test_indicator(self, dfs_for_indicator):
+        # PR #10054. xref #7412 and closes #8790.
+        df1, df2 = dfs_for_indicator
+        df1_copy = df1.copy()
+
+        df2_copy = df2.copy()
+
+        df_result = DataFrame(
+            {
+                "col1": [0, 1, 2, 3, 4, 5],
+                "col_conflict_x": [1, 2, np.nan, np.nan, np.nan, np.nan],
+                "col_left": ["a", "b", np.nan, np.nan, np.nan, np.nan],
+                "col_conflict_y": [np.nan, 1, 2, 3, 4, 5],
+                "col_right": [np.nan, 2, 2, 2, 2, 2],
+            }
+        )
+        df_result["_merge"] = Categorical(
+            [
+                "left_only",
+                "both",
+                "right_only",
+                "right_only",
+                "right_only",
+                "right_only",
+            ],
+            categories=["left_only", "right_only", "both"],
+        )
+
+        df_result = df_result[
+            [
+                "col1",
+                "col_conflict_x",
+                "col_left",
+                "col_conflict_y",
+                "col_right",
+                "_merge",
+            ]
+        ]
+
+        test = merge(df1, df2, on="col1", how="outer", indicator=True)
+        tm.assert_frame_equal(test, df_result)
+        test = df1.merge(df2, on="col1", how="outer", indicator=True)
+        tm.assert_frame_equal(test, df_result)
+
+        # No side effects
+        tm.assert_frame_equal(df1, df1_copy)
+        tm.assert_frame_equal(df2, df2_copy)
+
+        # Check with custom name
+        df_result_custom_name = df_result
+        df_result_custom_name = df_result_custom_name.rename(
+            columns={"_merge": "custom_name"}
+        )
+
+        test_custom_name = merge(
+            df1, df2, on="col1", how="outer", indicator="custom_name"
+        )
+        tm.assert_frame_equal(test_custom_name, df_result_custom_name)
+        test_custom_name = df1.merge(
+            df2, on="col1", how="outer", indicator="custom_name"
+        )
+        tm.assert_frame_equal(test_custom_name, df_result_custom_name)
+
+    def test_merge_indicator_arg_validation(self, dfs_for_indicator):
+        # Check only accepts strings and booleans
+        df1, df2 = dfs_for_indicator
+
+        msg = "indicator option can only accept boolean or string arguments"
+        with pytest.raises(ValueError, match=msg):
+            merge(df1, df2, on="col1", how="outer", indicator=5)
+        with pytest.raises(ValueError, match=msg):
+            df1.merge(df2, on="col1", how="outer", indicator=5)
+
+    def test_merge_indicator_result_integrity(self, dfs_for_indicator):
+        # Check result integrity
+        df1, df2 = dfs_for_indicator
+
+        test2 = merge(df1, df2, on="col1", how="left", indicator=True)
+        assert (test2._merge != "right_only").all()
+        test2 = df1.merge(df2, on="col1", how="left", indicator=True)
+        assert (test2._merge != "right_only").all()
+
+        test3 = merge(df1, df2, on="col1", how="right", indicator=True)
+        assert (test3._merge != "left_only").all()
+        test3 = df1.merge(df2, on="col1", how="right", indicator=True)
+        assert (test3._merge != "left_only").all()
+
+        test4 = merge(df1, df2, on="col1", how="inner", indicator=True)
+        assert (test4._merge == "both").all()
+        test4 = df1.merge(df2, on="col1", how="inner", indicator=True)
+        assert (test4._merge == "both").all()
+
+    def test_merge_indicator_invalid(self, dfs_for_indicator):
+        # Check if working name in df
+        df1, _ = dfs_for_indicator
+
+        for i in ["_right_indicator", "_left_indicator", "_merge"]:
+            df_badcolumn = DataFrame({"col1": [1, 2], i: [2, 2]})
+
+            msg = (
+                "Cannot use `indicator=True` option when data contains a "
+                f"column named {i}|"
+                "Cannot use name of an existing column for indicator column"
+            )
+            with pytest.raises(ValueError, match=msg):
+                merge(df1, df_badcolumn, on="col1", how="outer", indicator=True)
+            with pytest.raises(ValueError, match=msg):
+                df1.merge(df_badcolumn, on="col1", how="outer", indicator=True)
+
+        # Check for name conflict with custom name
+        df_badcolumn = DataFrame({"col1": [1, 2], "custom_column_name": [2, 2]})
+
+        msg = "Cannot use name of an existing column for indicator column"
+        with pytest.raises(ValueError, match=msg):
+            merge(
+                df1,
+                df_badcolumn,
+                on="col1",
+                how="outer",
+                indicator="custom_column_name",
+            )
+        with pytest.raises(ValueError, match=msg):
+            df1.merge(
+                df_badcolumn, on="col1", how="outer", indicator="custom_column_name"
+            )
+
+    def test_merge_indicator_multiple_columns(self):
+        # Merge on multiple columns
+        df3 = DataFrame({"col1": [0, 1], "col2": ["a", "b"]})
+
+        df4 = DataFrame({"col1": [1, 1, 3], "col2": ["b", "x", "y"]})
+
+        hand_coded_result = DataFrame(
+            {"col1": [0, 1, 1, 3], "col2": ["a", "b", "x", "y"]}
+        )
+        hand_coded_result["_merge"] = Categorical(
+            ["left_only", "both", "right_only", "right_only"],
+            categories=["left_only", "right_only", "both"],
+        )
+
+        test5 = merge(df3, df4, on=["col1", "col2"], how="outer", indicator=True)
+        tm.assert_frame_equal(test5, hand_coded_result)
+        test5 = df3.merge(df4, on=["col1", "col2"], how="outer", indicator=True)
+        tm.assert_frame_equal(test5, hand_coded_result)
+
+    def test_validation(self):
+        left = DataFrame(
+            {"a": ["a", "b", "c", "d"], "b": ["cat", "dog", "weasel", "horse"]},
+            index=range(4),
+        )
+
+        right = DataFrame(
+            {
+                "a": ["a", "b", "c", "d", "e"],
+                "c": ["meow", "bark", "um... weasel noise?", "nay", "chirp"],
+            },
+            index=range(5),
+        )
+
+        # Make sure no side effects.
+        left_copy = left.copy()
+        right_copy = right.copy()
+
+        result = merge(left, right, left_index=True, right_index=True, validate="1:1")
+        tm.assert_frame_equal(left, left_copy)
+        tm.assert_frame_equal(right, right_copy)
+
+        # make sure merge still correct
+        expected = DataFrame(
+            {
+                "a_x": ["a", "b", "c", "d"],
+                "b": ["cat", "dog", "weasel", "horse"],
+                "a_y": ["a", "b", "c", "d"],
+                "c": ["meow", "bark", "um... weasel noise?", "nay"],
+            },
+            index=range(4),
+            columns=["a_x", "b", "a_y", "c"],
+        )
+
+        result = merge(
+            left, right, left_index=True, right_index=True, validate="one_to_one"
+        )
+        tm.assert_frame_equal(result, expected)
+
+        expected_2 = DataFrame(
+            {
+                "a": ["a", "b", "c", "d"],
+                "b": ["cat", "dog", "weasel", "horse"],
+                "c": ["meow", "bark", "um... weasel noise?", "nay"],
+            },
+            index=range(4),
+        )
+
+        result = merge(left, right, on="a", validate="1:1")
+        tm.assert_frame_equal(left, left_copy)
+        tm.assert_frame_equal(right, right_copy)
+        tm.assert_frame_equal(result, expected_2)
+
+        result = merge(left, right, on="a", validate="one_to_one")
+        tm.assert_frame_equal(result, expected_2)
+
+        # One index, one column
+        expected_3 = DataFrame(
+            {
+                "b": ["cat", "dog", "weasel", "horse"],
+                "a": ["a", "b", "c", "d"],
+                "c": ["meow", "bark", "um... weasel noise?", "nay"],
+            },
+            columns=["b", "a", "c"],
+            index=range(4),
+        )
+
+        left_index_reset = left.set_index("a")
+        result = merge(
+            left_index_reset,
+            right,
+            left_index=True,
+            right_on="a",
+            validate="one_to_one",
+        )
+        tm.assert_frame_equal(result, expected_3)
+
+        # Dups on right
+        right_w_dups = concat([right, DataFrame({"a": ["e"], "c": ["moo"]}, index=[4])])
+        merge(
+            left,
+            right_w_dups,
+            left_index=True,
+            right_index=True,
+            validate="one_to_many",
+        )
+
+        msg = "Merge keys are not unique in right dataset; not a one-to-one merge"
+        with pytest.raises(MergeError, match=msg):
+            merge(
+                left,
+                right_w_dups,
+                left_index=True,
+                right_index=True,
+                validate="one_to_one",
+            )
+
+        with pytest.raises(MergeError, match=msg):
+            merge(left, right_w_dups, on="a", validate="one_to_one")
+
+        # Dups on left
+        left_w_dups = concat(
+            [left, DataFrame({"a": ["a"], "c": ["cow"]}, index=[3])], sort=True
+        )
+        merge(
+            left_w_dups,
+            right,
+            left_index=True,
+            right_index=True,
+            validate="many_to_one",
+        )
+
+        msg = "Merge keys are not unique in left dataset; not a one-to-one merge"
+        with pytest.raises(MergeError, match=msg):
+            merge(
+                left_w_dups,
+                right,
+                left_index=True,
+                right_index=True,
+                validate="one_to_one",
+            )
+
+        with pytest.raises(MergeError, match=msg):
+            merge(left_w_dups, right, on="a", validate="one_to_one")
+
+        # Dups on both
+        merge(left_w_dups, right_w_dups, on="a", validate="many_to_many")
+
+        msg = "Merge keys are not unique in right dataset; not a many-to-one merge"
+        with pytest.raises(MergeError, match=msg):
+            merge(
+                left_w_dups,
+                right_w_dups,
+                left_index=True,
+                right_index=True,
+                validate="many_to_one",
+            )
+
+        msg = "Merge keys are not unique in left dataset; not a one-to-many merge"
+        with pytest.raises(MergeError, match=msg):
+            merge(left_w_dups, right_w_dups, on="a", validate="one_to_many")
+
+        # Check invalid arguments
+        msg = (
+            '"jibberish" is not a valid argument. '
+            "Valid arguments are:\n"
+            '- "1:1"\n'
+            '- "1:m"\n'
+            '- "m:1"\n'
+            '- "m:m"\n'
+            '- "one_to_one"\n'
+            '- "one_to_many"\n'
+            '- "many_to_one"\n'
+            '- "many_to_many"'
+        )
+        with pytest.raises(ValueError, match=msg):
+            merge(left, right, on="a", validate="jibberish")
+
+        # Two column merge, dups in both, but jointly no dups.
+        left = DataFrame(
+            {
+                "a": ["a", "a", "b", "b"],
+                "b": [0, 1, 0, 1],
+                "c": ["cat", "dog", "weasel", "horse"],
+            },
+            index=range(4),
+        )
+
+        right = DataFrame(
+            {
+                "a": ["a", "a", "b"],
+                "b": [0, 1, 0],
+                "d": ["meow", "bark", "um... weasel noise?"],
+            },
+            index=range(3),
+        )
+
+        expected_multi = DataFrame(
+            {
+                "a": ["a", "a", "b"],
+                "b": [0, 1, 0],
+                "c": ["cat", "dog", "weasel"],
+                "d": ["meow", "bark", "um... weasel noise?"],
+            },
+            index=range(3),
+        )
+
+        msg = (
+            "Merge keys are not unique in either left or right dataset; "
+            "not a one-to-one merge"
+        )
+        with pytest.raises(MergeError, match=msg):
+            merge(left, right, on="a", validate="1:1")
+
+        result = merge(left, right, on=["a", "b"], validate="1:1")
+        tm.assert_frame_equal(result, expected_multi)
+
+    def test_merge_two_empty_df_no_division_error(self):
+        # GH17776, PR #17846
+        a = DataFrame({"a": [], "b": [], "c": []})
+        with np.errstate(divide="raise"):
+            merge(a, a, on=("a", "b"))
+
+    @pytest.mark.parametrize("how", ["right", "outer"])
+    @pytest.mark.parametrize(
+        "index,expected_index",
+        [
+            (
+                CategoricalIndex([1, 2, 4]),
+                CategoricalIndex([1, 2, 4, None, None, None]),
+            ),
+            (
+                DatetimeIndex(["2001-01-01", "2002-02-02", "2003-03-03"]),
+                DatetimeIndex(
+                    ["2001-01-01", "2002-02-02", "2003-03-03", pd.NaT, pd.NaT, pd.NaT]
+                ),
+            ),
+            *[
+                (
+                    Index([1, 2, 3], dtype=dtyp),
+                    Index([1, 2, 3, None, None, None], dtype=np.float64),
+                )
+                for dtyp in tm.ALL_REAL_NUMPY_DTYPES
+            ],
+            (
+                IntervalIndex.from_tuples([(1, 2), (2, 3), (3, 4)]),
+                IntervalIndex.from_tuples(
+                    [(1, 2), (2, 3), (3, 4), np.nan, np.nan, np.nan]
+                ),
+            ),
+            (
+                PeriodIndex(["2001-01-01", "2001-01-02", "2001-01-03"], freq="D"),
+                PeriodIndex(
+                    ["2001-01-01", "2001-01-02", "2001-01-03", pd.NaT, pd.NaT, pd.NaT],
+                    freq="D",
+                ),
+            ),
+            (
+                TimedeltaIndex(["1d", "2d", "3d"]),
+                TimedeltaIndex(["1d", "2d", "3d", pd.NaT, pd.NaT, pd.NaT]),
+            ),
+        ],
+    )
+    def test_merge_on_index_with_more_values(self, how, index, expected_index):
+        # GH 24212
+        # pd.merge gets [0, 1, 2, -1, -1, -1] as left_indexer, ensure that
+        # -1 is interpreted as a missing value instead of the last element
+        df1 = DataFrame({"a": [0, 1, 2], "key": [0, 1, 2]}, index=index)
+        df2 = DataFrame({"b": [0, 1, 2, 3, 4, 5]})
+        result = df1.merge(df2, left_on="key", right_index=True, how=how)
+        expected = DataFrame(
+            [
+                [0, 0, 0],
+                [1, 1, 1],
+                [2, 2, 2],
+                [np.nan, 3, 3],
+                [np.nan, 4, 4],
+                [np.nan, 5, 5],
+            ],
+            columns=["a", "key", "b"],
+        )
+        expected.set_index(expected_index, inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_right_index_right(self):
+        # Note: the expected output here is probably incorrect.
+        # See https://github.com/pandas-dev/pandas/issues/17257 for more.
+        # We include this as a regression test for GH-24897.
+        left = DataFrame({"a": [1, 2, 3], "key": [0, 1, 1]})
+        right = DataFrame({"b": [1, 2, 3]})
+
+        expected = DataFrame(
+            {"a": [1, 2, 3, None], "key": [0, 1, 1, 2], "b": [1, 2, 2, 3]},
+            columns=["a", "key", "b"],
+            index=[0, 1, 2, np.nan],
+        )
+        result = left.merge(right, left_on="key", right_index=True, how="right")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("how", ["left", "right"])
+    def test_merge_preserves_row_order(self, how):
+        # GH 27453
+        left_df = DataFrame({"animal": ["dog", "pig"], "max_speed": [40, 11]})
+        right_df = DataFrame({"animal": ["quetzal", "pig"], "max_speed": [80, 11]})
+        result = left_df.merge(right_df, on=["animal", "max_speed"], how=how)
+        if how == "right":
+            expected = DataFrame({"animal": ["quetzal", "pig"], "max_speed": [80, 11]})
+        else:
+            expected = DataFrame({"animal": ["dog", "pig"], "max_speed": [40, 11]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_take_missing_values_from_index_of_other_dtype(self):
+        # GH 24212
+        left = DataFrame(
+            {
+                "a": [1, 2, 3],
+                "key": Categorical(["a", "a", "b"], categories=list("abc")),
+            }
+        )
+        right = DataFrame({"b": [1, 2, 3]}, index=CategoricalIndex(["a", "b", "c"]))
+        result = left.merge(right, left_on="key", right_index=True, how="right")
+        expected = DataFrame(
+            {
+                "a": [1, 2, 3, None],
+                "key": Categorical(["a", "a", "b", "c"]),
+                "b": [1, 1, 2, 3],
+            },
+            index=[0, 1, 2, np.nan],
+        )
+        expected = expected.reindex(columns=["a", "key", "b"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_readonly(self):
+        # https://github.com/pandas-dev/pandas/issues/27943
+        data1 = DataFrame(
+            np.arange(20).reshape((4, 5)) + 1, columns=["a", "b", "c", "d", "e"]
+        )
+        data2 = DataFrame(
+            np.arange(20).reshape((5, 4)) + 1, columns=["a", "b", "x", "y"]
+        )
+
+        # make each underlying block array / column array read-only
+        for arr in data1._mgr.arrays:
+            arr.flags.writeable = False
+
+        data1.merge(data2)  # no error
+
+
+def _check_merge(x, y):
+    for how in ["inner", "left", "outer"]:
+        result = x.join(y, how=how)
+
+        expected = merge(x.reset_index(), y.reset_index(), how=how, sort=True)
+        expected = expected.set_index("index")
+
+        # TODO check_names on merge?
+        tm.assert_frame_equal(result, expected, check_names=False)
+
+
+class TestMergeDtypes:
+    @pytest.mark.parametrize(
+        "right_vals", [["foo", "bar"], Series(["foo", "bar"]).astype("category")]
+    )
+    def test_different(self, right_vals):
+        left = DataFrame(
+            {
+                "A": ["foo", "bar"],
+                "B": Series(["foo", "bar"]).astype("category"),
+                "C": [1, 2],
+                "D": [1.0, 2.0],
+                "E": Series([1, 2], dtype="uint64"),
+                "F": Series([1, 2], dtype="int32"),
+            }
+        )
+        right = DataFrame({"A": right_vals})
+
+        # GH 9780
+        # We allow merging on object and categorical cols and cast
+        # categorical cols to object
+        result = merge(left, right, on="A")
+        assert is_object_dtype(result.A.dtype)
+
+    @pytest.mark.parametrize(
+        "d1", [np.int64, np.int32, np.intc, np.int16, np.int8, np.uint8]
+    )
+    @pytest.mark.parametrize("d2", [np.int64, np.float64, np.float32, np.float16])
+    def test_join_multi_dtypes(self, d1, d2):
+        dtype1 = np.dtype(d1)
+        dtype2 = np.dtype(d2)
+
+        left = DataFrame(
+            {
+                "k1": np.array([0, 1, 2] * 8, dtype=dtype1),
+                "k2": ["foo", "bar"] * 12,
+                "v": np.array(np.arange(24), dtype=np.int64),
+            }
+        )
+
+        index = MultiIndex.from_tuples([(2, "bar"), (1, "foo")])
+        right = DataFrame({"v2": np.array([5, 7], dtype=dtype2)}, index=index)
+
+        result = left.join(right, on=["k1", "k2"])
+
+        expected = left.copy()
+
+        if dtype2.kind == "i":
+            dtype2 = np.dtype("float64")
+        expected["v2"] = np.array(np.nan, dtype=dtype2)
+        expected.loc[(expected.k1 == 2) & (expected.k2 == "bar"), "v2"] = 5
+        expected.loc[(expected.k1 == 1) & (expected.k2 == "foo"), "v2"] = 7
+
+        tm.assert_frame_equal(result, expected)
+
+        result = left.join(right, on=["k1", "k2"], sort=True)
+        expected.sort_values(["k1", "k2"], kind="mergesort", inplace=True)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "int_vals, float_vals, exp_vals",
+        [
+            ([1, 2, 3], [1.0, 2.0, 3.0], {"X": [1, 2, 3], "Y": [1.0, 2.0, 3.0]}),
+            ([1, 2, 3], [1.0, 3.0], {"X": [1, 3], "Y": [1.0, 3.0]}),
+            ([1, 2], [1.0, 2.0, 3.0], {"X": [1, 2], "Y": [1.0, 2.0]}),
+        ],
+    )
+    def test_merge_on_ints_floats(self, int_vals, float_vals, exp_vals):
+        # GH 16572
+        # Check that float column is not cast to object if
+        # merging on float and int columns
+        A = DataFrame({"X": int_vals})
+        B = DataFrame({"Y": float_vals})
+        expected = DataFrame(exp_vals)
+
+        result = A.merge(B, left_on="X", right_on="Y")
+        tm.assert_frame_equal(result, expected)
+
+        result = B.merge(A, left_on="Y", right_on="X")
+        tm.assert_frame_equal(result, expected[["Y", "X"]])
+
+    def test_merge_key_dtype_cast(self):
+        # GH 17044
+        df1 = DataFrame({"key": [1.0, 2.0], "v1": [10, 20]}, columns=["key", "v1"])
+        df2 = DataFrame({"key": [2], "v2": [200]}, columns=["key", "v2"])
+        result = df1.merge(df2, on="key", how="left")
+        expected = DataFrame(
+            {"key": [1.0, 2.0], "v1": [10, 20], "v2": [np.nan, 200.0]},
+            columns=["key", "v1", "v2"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_on_ints_floats_warning(self):
+        # GH 16572
+        # merge will produce a warning when merging on int and
+        # float columns where the float values are not exactly
+        # equal to their int representation
+        A = DataFrame({"X": [1, 2, 3]})
+        B = DataFrame({"Y": [1.1, 2.5, 3.0]})
+        expected = DataFrame({"X": [3], "Y": [3.0]})
+
+        with tm.assert_produces_warning(UserWarning):
+            result = A.merge(B, left_on="X", right_on="Y")
+            tm.assert_frame_equal(result, expected)
+
+        with tm.assert_produces_warning(UserWarning):
+            result = B.merge(A, left_on="Y", right_on="X")
+            tm.assert_frame_equal(result, expected[["Y", "X"]])
+
+        # test no warning if float has NaNs
+        B = DataFrame({"Y": [np.nan, np.nan, 3.0]})
+
+        with tm.assert_produces_warning(None):
+            result = B.merge(A, left_on="Y", right_on="X")
+            tm.assert_frame_equal(result, expected[["Y", "X"]])
+
+    def test_merge_incompat_infer_boolean_object(self):
+        # GH21119: bool + object bool merge OK
+        df1 = DataFrame({"key": Series([True, False], dtype=object)})
+        df2 = DataFrame({"key": [True, False]})
+
+        expected = DataFrame({"key": [True, False]}, dtype=object)
+        result = merge(df1, df2, on="key")
+        tm.assert_frame_equal(result, expected)
+        result = merge(df2, df1, on="key")
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_incompat_infer_boolean_object_with_missing(self):
+        # GH21119: bool + object bool merge OK
+        # with missing value
+        df1 = DataFrame({"key": Series([True, False, np.nan], dtype=object)})
+        df2 = DataFrame({"key": [True, False]})
+
+        expected = DataFrame({"key": [True, False]}, dtype=object)
+        result = merge(df1, df2, on="key")
+        tm.assert_frame_equal(result, expected)
+        result = merge(df2, df1, on="key")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "df1_vals, df2_vals",
+        [
+            # merge on category coerces to object
+            ([0, 1, 2], Series(["a", "b", "a"]).astype("category")),
+            ([0.0, 1.0, 2.0], Series(["a", "b", "a"]).astype("category")),
+            # no not infer
+            ([0, 1], Series([False, True], dtype=object)),
+            ([0, 1], Series([False, True], dtype=bool)),
+        ],
+    )
+    def test_merge_incompat_dtypes_are_ok(self, df1_vals, df2_vals):
+        # these are explicitly allowed incompat merges, that pass thru
+        # the result type is dependent on if the values on the rhs are
+        # inferred, otherwise these will be coerced to object
+
+        df1 = DataFrame({"A": df1_vals})
+        df2 = DataFrame({"A": df2_vals})
+
+        result = merge(df1, df2, on=["A"])
+        assert is_object_dtype(result.A.dtype)
+        result = merge(df2, df1, on=["A"])
+        assert is_object_dtype(result.A.dtype)
+
+    @pytest.mark.parametrize(
+        "df1_vals, df2_vals",
+        [
+            # do not infer to numeric
+            (Series([1, 2], dtype="uint64"), ["a", "b", "c"]),
+            (Series([1, 2], dtype="int32"), ["a", "b", "c"]),
+            ([0, 1, 2], ["0", "1", "2"]),
+            ([0.0, 1.0, 2.0], ["0", "1", "2"]),
+            ([0, 1, 2], ["0", "1", "2"]),
+            (
+                pd.date_range("1/1/2011", periods=2, freq="D"),
+                ["2011-01-01", "2011-01-02"],
+            ),
+            (pd.date_range("1/1/2011", periods=2, freq="D"), [0, 1]),
+            (pd.date_range("1/1/2011", periods=2, freq="D"), [0.0, 1.0]),
+            (
+                pd.date_range("20130101", periods=3),
+                pd.date_range("20130101", periods=3, tz="US/Eastern"),
+            ),
+        ],
+    )
+    def test_merge_incompat_dtypes_error(self, df1_vals, df2_vals):
+        # GH 9780, GH 15800
+        # Raise a ValueError when a user tries to merge on
+        # dtypes that are incompatible (e.g., obj and int/float)
+
+        df1 = DataFrame({"A": df1_vals})
+        df2 = DataFrame({"A": df2_vals})
+
+        msg = (
+            f"You are trying to merge on {df1['A'].dtype} and {df2['A'].dtype} "
+            "columns for key 'A'. If you wish to proceed you should use pd.concat"
+        )
+        msg = re.escape(msg)
+        with pytest.raises(ValueError, match=msg):
+            merge(df1, df2, on=["A"])
+
+        # Check that error still raised when swapping order of dataframes
+        msg = (
+            f"You are trying to merge on {df2['A'].dtype} and {df1['A'].dtype} "
+            "columns for key 'A'. If you wish to proceed you should use pd.concat"
+        )
+        msg = re.escape(msg)
+        with pytest.raises(ValueError, match=msg):
+            merge(df2, df1, on=["A"])
+
+        # Check that error still raised when merging on multiple columns
+        # The error message should mention the first incompatible column
+        if len(df1_vals) == len(df2_vals):
+            # Column A in df1 and df2 is of compatible (the same) dtype
+            # Columns B and C in df1 and df2 are of incompatible dtypes
+            df3 = DataFrame({"A": df2_vals, "B": df1_vals, "C": df1_vals})
+            df4 = DataFrame({"A": df2_vals, "B": df2_vals, "C": df2_vals})
+
+            # Check that error raised correctly when merging all columns A, B, and C
+            # The error message should mention key 'B'
+            msg = (
+                f"You are trying to merge on {df3['B'].dtype} and {df4['B'].dtype} "
+                "columns for key 'B'. If you wish to proceed you should use pd.concat"
+            )
+            msg = re.escape(msg)
+            with pytest.raises(ValueError, match=msg):
+                merge(df3, df4)
+
+            # Check that error raised correctly when merging columns A and C
+            # The error message should mention key 'C'
+            msg = (
+                f"You are trying to merge on {df3['C'].dtype} and {df4['C'].dtype} "
+                "columns for key 'C'. If you wish to proceed you should use pd.concat"
+            )
+            msg = re.escape(msg)
+            with pytest.raises(ValueError, match=msg):
+                merge(df3, df4, on=["A", "C"])
+
+    @pytest.mark.parametrize(
+        "expected_data, how",
+        [
+            ([1, 2], "outer"),
+            ([], "inner"),
+            ([2], "right"),
+            ([1], "left"),
+        ],
+    )
+    def test_merge_EA_dtype(self, any_numeric_ea_dtype, how, expected_data):
+        # GH#40073
+        d1 = DataFrame([(1,)], columns=["id"], dtype=any_numeric_ea_dtype)
+        d2 = DataFrame([(2,)], columns=["id"], dtype=any_numeric_ea_dtype)
+        result = merge(d1, d2, how=how)
+        exp_index = RangeIndex(len(expected_data))
+        expected = DataFrame(
+            expected_data, index=exp_index, columns=["id"], dtype=any_numeric_ea_dtype
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "expected_data, how",
+        [
+            (["a", "b"], "outer"),
+            ([], "inner"),
+            (["b"], "right"),
+            (["a"], "left"),
+        ],
+    )
+    def test_merge_string_dtype(self, how, expected_data, any_string_dtype):
+        # GH#40073
+        d1 = DataFrame([("a",)], columns=["id"], dtype=any_string_dtype)
+        d2 = DataFrame([("b",)], columns=["id"], dtype=any_string_dtype)
+        result = merge(d1, d2, how=how)
+        exp_idx = RangeIndex(len(expected_data))
+        expected = DataFrame(
+            expected_data, index=exp_idx, columns=["id"], dtype=any_string_dtype
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "how, expected_data",
+        [
+            ("inner", [[True, 1, 4], [False, 5, 3]]),
+            ("outer", [[True, 1, 4], [False, 5, 3]]),
+            ("left", [[True, 1, 4], [False, 5, 3]]),
+            ("right", [[False, 5, 3], [True, 1, 4]]),
+        ],
+    )
+    def test_merge_bool_dtype(self, how, expected_data):
+        # GH#40073
+        df1 = DataFrame({"A": [True, False], "B": [1, 5]})
+        df2 = DataFrame({"A": [False, True], "C": [3, 4]})
+        result = merge(df1, df2, how=how)
+        expected = DataFrame(expected_data, columns=["A", "B", "C"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_ea_with_string(self, join_type, string_dtype):
+        # GH 43734 Avoid the use of `assign` with multi-index
+        df1 = DataFrame(
+            data={
+                ("lvl0", "lvl1-a"): ["1", "2", "3", "4", None],
+                ("lvl0", "lvl1-b"): ["4", "5", "6", "7", "8"],
+            },
+            dtype=pd.StringDtype(),
+        )
+        df1_copy = df1.copy()
+        df2 = DataFrame(
+            data={
+                ("lvl0", "lvl1-a"): ["1", "2", "3", pd.NA, "5"],
+                ("lvl0", "lvl1-c"): ["7", "8", "9", pd.NA, "11"],
+            },
+            dtype=string_dtype,
+        )
+        df2_copy = df2.copy()
+        merged = merge(left=df1, right=df2, on=[("lvl0", "lvl1-a")], how=join_type)
+
+        # No change in df1 and df2
+        tm.assert_frame_equal(df1, df1_copy)
+        tm.assert_frame_equal(df2, df2_copy)
+
+        # Check the expected types for the merged data frame
+        expected = Series(
+            [np.dtype("O"), pd.StringDtype(), np.dtype("O")],
+            index=MultiIndex.from_tuples(
+                [("lvl0", "lvl1-a"), ("lvl0", "lvl1-b"), ("lvl0", "lvl1-c")]
+            ),
+        )
+        tm.assert_series_equal(merged.dtypes, expected)
+
+    @pytest.mark.parametrize(
+        "left_empty, how, exp",
+        [
+            (False, "left", "left"),
+            (False, "right", "empty"),
+            (False, "inner", "empty"),
+            (False, "outer", "left"),
+            (False, "cross", "empty_cross"),
+            (True, "left", "empty"),
+            (True, "right", "right"),
+            (True, "inner", "empty"),
+            (True, "outer", "right"),
+            (True, "cross", "empty_cross"),
+        ],
+    )
+    def test_merge_empty(self, left_empty, how, exp):
+        left = DataFrame({"A": [2, 1], "B": [3, 4]})
+        right = DataFrame({"A": [1], "C": [5]}, dtype="int64")
+
+        if left_empty:
+            left = left.head(0)
+        else:
+            right = right.head(0)
+
+        result = left.merge(right, how=how)
+
+        if exp == "left":
+            expected = DataFrame({"A": [2, 1], "B": [3, 4], "C": [np.nan, np.nan]})
+        elif exp == "right":
+            expected = DataFrame({"B": [np.nan], "A": [1], "C": [5]})
+        elif exp == "empty":
+            expected = DataFrame(columns=["A", "B", "C"], dtype="int64")
+            if left_empty:
+                expected = expected[["B", "A", "C"]]
+        elif exp == "empty_cross":
+            expected = DataFrame(columns=["A_x", "B", "A_y", "C"], dtype="int64")
+
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.fixture
+def left():
+    return DataFrame(
+        {
+            "X": Series(
+                np.random.default_rng(2).choice(["foo", "bar"], size=(10,))
+            ).astype(CDT(["foo", "bar"])),
+            "Y": np.random.default_rng(2).choice(["one", "two", "three"], size=(10,)),
+        }
+    )
+
+
+@pytest.fixture
+def right():
+    return DataFrame(
+        {"X": Series(["foo", "bar"]).astype(CDT(["foo", "bar"])), "Z": [1, 2]}
+    )
+
+
+class TestMergeCategorical:
+    def test_identical(self, left):
+        # merging on the same, should preserve dtypes
+        merged = merge(left, left, on="X")
+        result = merged.dtypes.sort_index()
+        expected = Series(
+            [CategoricalDtype(categories=["foo", "bar"]), np.dtype("O"), np.dtype("O")],
+            index=["X", "Y_x", "Y_y"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_basic(self, left, right):
+        # we have matching Categorical dtypes in X
+        # so should preserve the merged column
+        merged = merge(left, right, on="X")
+        result = merged.dtypes.sort_index()
+        expected = Series(
+            [
+                CategoricalDtype(categories=["foo", "bar"]),
+                np.dtype("O"),
+                np.dtype("int64"),
+            ],
+            index=["X", "Y", "Z"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_merge_categorical(self):
+        # GH 9426
+
+        right = DataFrame(
+            {
+                "c": {0: "a", 1: "b", 2: "c", 3: "d", 4: "e"},
+                "d": {0: "null", 1: "null", 2: "null", 3: "null", 4: "null"},
+            }
+        )
+        left = DataFrame(
+            {
+                "a": {0: "f", 1: "f", 2: "f", 3: "f", 4: "f"},
+                "b": {0: "g", 1: "g", 2: "g", 3: "g", 4: "g"},
+            }
+        )
+        df = merge(left, right, how="left", left_on="b", right_on="c")
+
+        # object-object
+        expected = df.copy()
+
+        # object-cat
+        # note that we propagate the category
+        # because we don't have any matching rows
+        cright = right.copy()
+        cright["d"] = cright["d"].astype("category")
+        result = merge(left, cright, how="left", left_on="b", right_on="c")
+        expected["d"] = expected["d"].astype(CategoricalDtype(["null"]))
+        tm.assert_frame_equal(result, expected)
+
+        # cat-object
+        cleft = left.copy()
+        cleft["b"] = cleft["b"].astype("category")
+        result = merge(cleft, cright, how="left", left_on="b", right_on="c")
+        tm.assert_frame_equal(result, expected)
+
+        # cat-cat
+        cright = right.copy()
+        cright["d"] = cright["d"].astype("category")
+        cleft = left.copy()
+        cleft["b"] = cleft["b"].astype("category")
+        result = merge(cleft, cright, how="left", left_on="b", right_on="c")
+        tm.assert_frame_equal(result, expected)
+
+    def tests_merge_categorical_unordered_equal(self):
+        # GH-19551
+        df1 = DataFrame(
+            {
+                "Foo": Categorical(["A", "B", "C"], categories=["A", "B", "C"]),
+                "Left": ["A0", "B0", "C0"],
+            }
+        )
+
+        df2 = DataFrame(
+            {
+                "Foo": Categorical(["C", "B", "A"], categories=["C", "B", "A"]),
+                "Right": ["C1", "B1", "A1"],
+            }
+        )
+        result = merge(df1, df2, on=["Foo"])
+        expected = DataFrame(
+            {
+                "Foo": Categorical(["A", "B", "C"]),
+                "Left": ["A0", "B0", "C0"],
+                "Right": ["A1", "B1", "C1"],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("ordered", [True, False])
+    def test_multiindex_merge_with_unordered_categoricalindex(self, ordered):
+        # GH 36973
+        pcat = CategoricalDtype(categories=["P2", "P1"], ordered=ordered)
+        df1 = DataFrame(
+            {
+                "id": ["C", "C", "D"],
+                "p": Categorical(["P2", "P1", "P2"], dtype=pcat),
+                "a": [0, 1, 2],
+            }
+        ).set_index(["id", "p"])
+        df2 = DataFrame(
+            {
+                "id": ["A", "C", "C"],
+                "p": Categorical(["P2", "P2", "P1"], dtype=pcat),
+                "d1": [10, 11, 12],
+            }
+        ).set_index(["id", "p"])
+        result = merge(df1, df2, how="left", left_index=True, right_index=True)
+        expected = DataFrame(
+            {
+                "id": ["C", "C", "D"],
+                "p": Categorical(["P2", "P1", "P2"], dtype=pcat),
+                "a": [0, 1, 2],
+                "d1": [11.0, 12.0, np.nan],
+            }
+        ).set_index(["id", "p"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_other_columns(self, left, right):
+        # non-merge columns should preserve if possible
+        right = right.assign(Z=right.Z.astype("category"))
+
+        merged = merge(left, right, on="X")
+        result = merged.dtypes.sort_index()
+        expected = Series(
+            [
+                CategoricalDtype(categories=["foo", "bar"]),
+                np.dtype("O"),
+                CategoricalDtype(categories=[1, 2]),
+            ],
+            index=["X", "Y", "Z"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        # categories are preserved
+        assert left.X.values._categories_match_up_to_permutation(merged.X.values)
+        assert right.Z.values._categories_match_up_to_permutation(merged.Z.values)
+
+    @pytest.mark.parametrize(
+        "change",
+        [
+            lambda x: x,
+            lambda x: x.astype(CDT(["foo", "bar", "bah"])),
+            lambda x: x.astype(CDT(ordered=True)),
+        ],
+    )
+    def test_dtype_on_merged_different(self, change, join_type, left, right):
+        # our merging columns, X now has 2 different dtypes
+        # so we must be object as a result
+
+        X = change(right.X.astype("object"))
+        right = right.assign(X=X)
+        assert isinstance(left.X.values.dtype, CategoricalDtype)
+        # assert not left.X.values._categories_match_up_to_permutation(right.X.values)
+
+        merged = merge(left, right, on="X", how=join_type)
+
+        result = merged.dtypes.sort_index()
+        expected = Series(
+            [np.dtype("O"), np.dtype("O"), np.dtype("int64")], index=["X", "Y", "Z"]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_self_join_multiple_categories(self):
+        # GH 16767
+        # non-duplicates should work with multiple categories
+        m = 5
+        df = DataFrame(
+            {
+                "a": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"] * m,
+                "b": ["t", "w", "x", "y", "z"] * 2 * m,
+                "c": [
+                    letter
+                    for each in ["m", "n", "u", "p", "o"]
+                    for letter in [each] * 2 * m
+                ],
+                "d": [
+                    letter
+                    for each in [
+                        "aa",
+                        "bb",
+                        "cc",
+                        "dd",
+                        "ee",
+                        "ff",
+                        "gg",
+                        "hh",
+                        "ii",
+                        "jj",
+                    ]
+                    for letter in [each] * m
+                ],
+            }
+        )
+
+        # change them all to categorical variables
+        df = df.apply(lambda x: x.astype("category"))
+
+        # self-join should equal ourselves
+        result = merge(df, df, on=list(df.columns))
+
+        tm.assert_frame_equal(result, df)
+
+    def test_dtype_on_categorical_dates(self):
+        # GH 16900
+        # dates should not be coerced to ints
+
+        df = DataFrame(
+            [[date(2001, 1, 1), 1.1], [date(2001, 1, 2), 1.3]], columns=["date", "num2"]
+        )
+        df["date"] = df["date"].astype("category")
+
+        df2 = DataFrame(
+            [[date(2001, 1, 1), 1.3], [date(2001, 1, 3), 1.4]], columns=["date", "num4"]
+        )
+        df2["date"] = df2["date"].astype("category")
+
+        expected_outer = DataFrame(
+            [
+                [pd.Timestamp("2001-01-01").date(), 1.1, 1.3],
+                [pd.Timestamp("2001-01-02").date(), 1.3, np.nan],
+                [pd.Timestamp("2001-01-03").date(), np.nan, 1.4],
+            ],
+            columns=["date", "num2", "num4"],
+        )
+        result_outer = merge(df, df2, how="outer", on=["date"])
+        tm.assert_frame_equal(result_outer, expected_outer)
+
+        expected_inner = DataFrame(
+            [[pd.Timestamp("2001-01-01").date(), 1.1, 1.3]],
+            columns=["date", "num2", "num4"],
+        )
+        result_inner = merge(df, df2, how="inner", on=["date"])
+        tm.assert_frame_equal(result_inner, expected_inner)
+
+    @pytest.mark.parametrize("ordered", [True, False])
+    @pytest.mark.parametrize(
+        "category_column,categories,expected_categories",
+        [
+            ([False, True, True, False], [True, False], [True, False]),
+            ([2, 1, 1, 2], [1, 2], [1, 2]),
+            (["False", "True", "True", "False"], ["True", "False"], ["True", "False"]),
+        ],
+    )
+    def test_merging_with_bool_or_int_cateorical_column(
+        self, category_column, categories, expected_categories, ordered
+    ):
+        # GH 17187
+        # merging with a boolean/int categorical column
+        df1 = DataFrame({"id": [1, 2, 3, 4], "cat": category_column})
+        df1["cat"] = df1["cat"].astype(CDT(categories, ordered=ordered))
+        df2 = DataFrame({"id": [2, 4], "num": [1, 9]})
+        result = df1.merge(df2)
+        expected = DataFrame({"id": [2, 4], "cat": expected_categories, "num": [1, 9]})
+        expected["cat"] = expected["cat"].astype(CDT(categories, ordered=ordered))
+        tm.assert_frame_equal(expected, result)
+
+    def test_merge_on_int_array(self):
+        # GH 23020
+        df = DataFrame({"A": Series([1, 2, np.nan], dtype="Int64"), "B": 1})
+        result = merge(df, df, on="A")
+        expected = DataFrame(
+            {"A": Series([1, 2, np.nan], dtype="Int64"), "B_x": 1, "B_y": 1}
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.fixture
+def left_df():
+    return DataFrame({"a": [20, 10, 0]}, index=[2, 1, 0])
+
+
+@pytest.fixture
+def right_df():
+    return DataFrame({"b": [300, 100, 200]}, index=[3, 1, 2])
+
+
+class TestMergeOnIndexes:
+    @pytest.mark.parametrize(
+        "how, sort, expected",
+        [
+            ("inner", False, DataFrame({"a": [20, 10], "b": [200, 100]}, index=[2, 1])),
+            ("inner", True, DataFrame({"a": [10, 20], "b": [100, 200]}, index=[1, 2])),
+            (
+                "left",
+                False,
+                DataFrame({"a": [20, 10, 0], "b": [200, 100, np.nan]}, index=[2, 1, 0]),
+            ),
+            (
+                "left",
+                True,
+                DataFrame({"a": [0, 10, 20], "b": [np.nan, 100, 200]}, index=[0, 1, 2]),
+            ),
+            (
+                "right",
+                False,
+                DataFrame(
+                    {"a": [np.nan, 10, 20], "b": [300, 100, 200]}, index=[3, 1, 2]
+                ),
+            ),
+            (
+                "right",
+                True,
+                DataFrame(
+                    {"a": [10, 20, np.nan], "b": [100, 200, 300]}, index=[1, 2, 3]
+                ),
+            ),
+            (
+                "outer",
+                False,
+                DataFrame(
+                    {"a": [0, 10, 20, np.nan], "b": [np.nan, 100, 200, 300]},
+                    index=[0, 1, 2, 3],
+                ),
+            ),
+            (
+                "outer",
+                True,
+                DataFrame(
+                    {"a": [0, 10, 20, np.nan], "b": [np.nan, 100, 200, 300]},
+                    index=[0, 1, 2, 3],
+                ),
+            ),
+        ],
+    )
+    def test_merge_on_indexes(self, left_df, right_df, how, sort, expected):
+        result = merge(
+            left_df, right_df, left_index=True, right_index=True, how=how, sort=sort
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "index",
+    [Index([1, 2], dtype=dtyp, name="index_col") for dtyp in tm.ALL_REAL_NUMPY_DTYPES]
+    + [
+        CategoricalIndex(["A", "B"], categories=["A", "B"], name="index_col"),
+        RangeIndex(start=0, stop=2, name="index_col"),
+        DatetimeIndex(["2018-01-01", "2018-01-02"], name="index_col"),
+    ],
+    ids=lambda x: f"{type(x).__name__}[{x.dtype}]",
+)
+def test_merge_index_types(index):
+    # gh-20777
+    # assert key access is consistent across index types
+    left = DataFrame({"left_data": [1, 2]}, index=index)
+    right = DataFrame({"right_data": [1.0, 2.0]}, index=index)
+
+    result = left.merge(right, on=["index_col"])
+
+    expected = DataFrame({"left_data": [1, 2], "right_data": [1.0, 2.0]}, index=index)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "on,left_on,right_on,left_index,right_index,nm",
+    [
+        (["outer", "inner"], None, None, False, False, "B"),
+        (None, None, None, True, True, "B"),
+        (None, ["outer", "inner"], None, False, True, "B"),
+        (None, None, ["outer", "inner"], True, False, "B"),
+        (["outer", "inner"], None, None, False, False, None),
+        (None, None, None, True, True, None),
+        (None, ["outer", "inner"], None, False, True, None),
+        (None, None, ["outer", "inner"], True, False, None),
+    ],
+)
+def test_merge_series(on, left_on, right_on, left_index, right_index, nm):
+    # GH 21220
+    a = DataFrame(
+        {"A": [1, 2, 3, 4]},
+        index=MultiIndex.from_product([["a", "b"], [0, 1]], names=["outer", "inner"]),
+    )
+    b = Series(
+        [1, 2, 3, 4],
+        index=MultiIndex.from_product([["a", "b"], [1, 2]], names=["outer", "inner"]),
+        name=nm,
+    )
+    expected = DataFrame(
+        {"A": [2, 4], "B": [1, 3]},
+        index=MultiIndex.from_product([["a", "b"], [1]], names=["outer", "inner"]),
+    )
+    if nm is not None:
+        result = merge(
+            a,
+            b,
+            on=on,
+            left_on=left_on,
+            right_on=right_on,
+            left_index=left_index,
+            right_index=right_index,
+        )
+        tm.assert_frame_equal(result, expected)
+    else:
+        msg = "Cannot merge a Series without a name"
+        with pytest.raises(ValueError, match=msg):
+            result = merge(
+                a,
+                b,
+                on=on,
+                left_on=left_on,
+                right_on=right_on,
+                left_index=left_index,
+                right_index=right_index,
+            )
+
+
+def test_merge_series_multilevel():
+    # GH#47946
+    # GH 40993: For raising, enforced in 2.0
+    a = DataFrame(
+        {"A": [1, 2, 3, 4]},
+        index=MultiIndex.from_product([["a", "b"], [0, 1]], names=["outer", "inner"]),
+    )
+    b = Series(
+        [1, 2, 3, 4],
+        index=MultiIndex.from_product([["a", "b"], [1, 2]], names=["outer", "inner"]),
+        name=("B", "C"),
+    )
+    with pytest.raises(
+        MergeError, match="Not allowed to merge between different levels"
+    ):
+        merge(a, b, on=["outer", "inner"])
+
+
+@pytest.mark.parametrize(
+    "col1, col2, kwargs, expected_cols",
+    [
+        (0, 0, {"suffixes": ("", "_dup")}, ["0", "0_dup"]),
+        (0, 0, {"suffixes": (None, "_dup")}, [0, "0_dup"]),
+        (0, 0, {"suffixes": ("_x", "_y")}, ["0_x", "0_y"]),
+        (0, 0, {"suffixes": ["_x", "_y"]}, ["0_x", "0_y"]),
+        ("a", 0, {"suffixes": (None, "_y")}, ["a", 0]),
+        (0.0, 0.0, {"suffixes": ("_x", None)}, ["0.0_x", 0.0]),
+        ("b", "b", {"suffixes": (None, "_y")}, ["b", "b_y"]),
+        ("a", "a", {"suffixes": ("_x", None)}, ["a_x", "a"]),
+        ("a", "b", {"suffixes": ("_x", None)}, ["a", "b"]),
+        ("a", "a", {"suffixes": (None, "_x")}, ["a", "a_x"]),
+        (0, 0, {"suffixes": ("_a", None)}, ["0_a", 0]),
+        ("a", "a", {}, ["a_x", "a_y"]),
+        (0, 0, {}, ["0_x", "0_y"]),
+    ],
+)
+def test_merge_suffix(col1, col2, kwargs, expected_cols):
+    # issue: 24782
+    a = DataFrame({col1: [1, 2, 3]})
+    b = DataFrame({col2: [4, 5, 6]})
+
+    expected = DataFrame([[1, 4], [2, 5], [3, 6]], columns=expected_cols)
+
+    result = a.merge(b, left_index=True, right_index=True, **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+    result = merge(a, b, left_index=True, right_index=True, **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "how,expected",
+    [
+        (
+            "right",
+            DataFrame(
+                {"A": [100, 200, 300], "B1": [60, 70, np.nan], "B2": [600, 700, 800]}
+            ),
+        ),
+        (
+            "outer",
+            DataFrame(
+                {
+                    "A": [100, 200, 1, 300],
+                    "B1": [60, 70, 80, np.nan],
+                    "B2": [600, 700, np.nan, 800],
+                }
+            ),
+        ),
+    ],
+)
+def test_merge_duplicate_suffix(how, expected):
+    left_df = DataFrame({"A": [100, 200, 1], "B": [60, 70, 80]})
+    right_df = DataFrame({"A": [100, 200, 300], "B": [600, 700, 800]})
+    result = merge(left_df, right_df, on="A", how=how, suffixes=("_x", "_x"))
+    expected.columns = ["A", "B_x", "B_x"]
+
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "col1, col2, suffixes",
+    [("a", "a", (None, None)), ("a", "a", ("", None)), (0, 0, (None, ""))],
+)
+def test_merge_suffix_error(col1, col2, suffixes):
+    # issue: 24782
+    a = DataFrame({col1: [1, 2, 3]})
+    b = DataFrame({col2: [3, 4, 5]})
+
+    # TODO: might reconsider current raise behaviour, see issue 24782
+    msg = "columns overlap but no suffix specified"
+    with pytest.raises(ValueError, match=msg):
+        merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
+
+
+@pytest.mark.parametrize("suffixes", [{"left", "right"}, {"left": 0, "right": 0}])
+def test_merge_suffix_raises(suffixes):
+    a = DataFrame({"a": [1, 2, 3]})
+    b = DataFrame({"b": [3, 4, 5]})
+
+    with pytest.raises(TypeError, match="Passing 'suffixes' as a"):
+        merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
+
+
+@pytest.mark.parametrize(
+    "col1, col2, suffixes, msg",
+    [
+        ("a", "a", ("a", "b", "c"), r"too many values to unpack \(expected 2\)"),
+        ("a", "a", tuple("a"), r"not enough values to unpack \(expected 2, got 1\)"),
+    ],
+)
+def test_merge_suffix_length_error(col1, col2, suffixes, msg):
+    a = DataFrame({col1: [1, 2, 3]})
+    b = DataFrame({col2: [3, 4, 5]})
+
+    with pytest.raises(ValueError, match=msg):
+        merge(a, b, left_index=True, right_index=True, suffixes=suffixes)
+
+
+@pytest.mark.parametrize("cat_dtype", ["one", "two"])
+@pytest.mark.parametrize("reverse", [True, False])
+def test_merge_equal_cat_dtypes(cat_dtype, reverse):
+    # see gh-22501
+    cat_dtypes = {
+        "one": CategoricalDtype(categories=["a", "b", "c"], ordered=False),
+        "two": CategoricalDtype(categories=["a", "b", "c"], ordered=False),
+    }
+
+    df1 = DataFrame(
+        {"foo": Series(["a", "b", "c"]).astype(cat_dtypes["one"]), "left": [1, 2, 3]}
+    ).set_index("foo")
+
+    data_foo = ["a", "b", "c"]
+    data_right = [1, 2, 3]
+
+    if reverse:
+        data_foo.reverse()
+        data_right.reverse()
+
+    df2 = DataFrame(
+        {"foo": Series(data_foo).astype(cat_dtypes[cat_dtype]), "right": data_right}
+    ).set_index("foo")
+
+    result = df1.merge(df2, left_index=True, right_index=True)
+
+    expected = DataFrame(
+        {
+            "left": [1, 2, 3],
+            "right": [1, 2, 3],
+            "foo": Series(["a", "b", "c"]).astype(cat_dtypes["one"]),
+        }
+    ).set_index("foo")
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_equal_cat_dtypes2():
+    # see gh-22501
+    cat_dtype = CategoricalDtype(categories=["a", "b", "c"], ordered=False)
+
+    # Test Data
+    df1 = DataFrame(
+        {"foo": Series(["a", "b"]).astype(cat_dtype), "left": [1, 2]}
+    ).set_index("foo")
+
+    df2 = DataFrame(
+        {"foo": Series(["a", "b", "c"]).astype(cat_dtype), "right": [3, 2, 1]}
+    ).set_index("foo")
+
+    result = df1.merge(df2, left_index=True, right_index=True)
+
+    expected = DataFrame(
+        {"left": [1, 2], "right": [3, 2], "foo": Series(["a", "b"]).astype(cat_dtype)}
+    ).set_index("foo")
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_on_cat_and_ext_array():
+    # GH 28668
+    right = DataFrame(
+        {"a": Series([pd.Interval(0, 1), pd.Interval(1, 2)], dtype="interval")}
+    )
+    left = right.copy()
+    left["a"] = left["a"].astype("category")
+
+    result = merge(left, right, how="inner", on="a")
+    expected = right.copy()
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_multiindex_columns():
+    # Issue #28518
+    # Verify that merging two dataframes give the expected labels
+    # The original cause of this issue come from a bug lexsort_depth and is tested in
+    # test_lexsort_depth
+
+    letters = ["a", "b", "c", "d"]
+    numbers = ["1", "2", "3"]
+    index = MultiIndex.from_product((letters, numbers), names=["outer", "inner"])
+
+    frame_x = DataFrame(columns=index)
+    frame_x["id"] = ""
+    frame_y = DataFrame(columns=index)
+    frame_y["id"] = ""
+
+    l_suf = "_x"
+    r_suf = "_y"
+    result = frame_x.merge(frame_y, on="id", suffixes=((l_suf, r_suf)))
+
+    # Constructing the expected results
+    expected_labels = [letter + l_suf for letter in letters] + [
+        letter + r_suf for letter in letters
+    ]
+    expected_index = MultiIndex.from_product(
+        [expected_labels, numbers], names=["outer", "inner"]
+    )
+    expected = DataFrame(columns=expected_index)
+    expected["id"] = ""
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_datetime_upcast_dtype():
+    # https://github.com/pandas-dev/pandas/issues/31208
+    df1 = DataFrame({"x": ["a", "b", "c"], "y": ["1", "2", "4"]})
+    df2 = DataFrame(
+        {"y": ["1", "2", "3"], "z": pd.to_datetime(["2000", "2001", "2002"])}
+    )
+    result = merge(df1, df2, how="left", on="y")
+    expected = DataFrame(
+        {
+            "x": ["a", "b", "c"],
+            "y": ["1", "2", "4"],
+            "z": pd.to_datetime(["2000", "2001", "NaT"]),
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("n_categories", [5, 128])
+def test_categorical_non_unique_monotonic(n_categories):
+    # GH 28189
+    # With n_categories as 5, we test the int8 case is hit in libjoin,
+    # with n_categories as 128 we test the int16 case.
+    left_index = CategoricalIndex([0] + list(range(n_categories)))
+    df1 = DataFrame(range(n_categories + 1), columns=["value"], index=left_index)
+    df2 = DataFrame(
+        [[6]],
+        columns=["value"],
+        index=CategoricalIndex([0], categories=list(range(n_categories))),
+    )
+
+    result = merge(df1, df2, how="left", left_index=True, right_index=True)
+    expected = DataFrame(
+        [[i, 6.0] if i < 2 else [i, np.nan] for i in range(n_categories + 1)],
+        columns=["value_x", "value_y"],
+        index=left_index,
+    )
+    tm.assert_frame_equal(expected, result)
+
+
+def test_merge_join_categorical_multiindex():
+    # From issue 16627
+    a = {
+        "Cat1": Categorical(["a", "b", "a", "c", "a", "b"], ["a", "b", "c"]),
+        "Int1": [0, 1, 0, 1, 0, 0],
+    }
+    a = DataFrame(a)
+
+    b = {
+        "Cat": Categorical(["a", "b", "c", "a", "b", "c"], ["a", "b", "c"]),
+        "Int": [0, 0, 0, 1, 1, 1],
+        "Factor": [1.1, 1.2, 1.3, 1.4, 1.5, 1.6],
+    }
+    b = DataFrame(b).set_index(["Cat", "Int"])["Factor"]
+
+    expected = merge(
+        a,
+        b.reset_index(),
+        left_on=["Cat1", "Int1"],
+        right_on=["Cat", "Int"],
+        how="left",
+    )
+    expected = expected.drop(["Cat", "Int"], axis=1)
+    result = a.join(b, on=["Cat1", "Int1"])
+    tm.assert_frame_equal(expected, result)
+
+    # Same test, but with ordered categorical
+    a = {
+        "Cat1": Categorical(
+            ["a", "b", "a", "c", "a", "b"], ["b", "a", "c"], ordered=True
+        ),
+        "Int1": [0, 1, 0, 1, 0, 0],
+    }
+    a = DataFrame(a)
+
+    b = {
+        "Cat": Categorical(
+            ["a", "b", "c", "a", "b", "c"], ["b", "a", "c"], ordered=True
+        ),
+        "Int": [0, 0, 0, 1, 1, 1],
+        "Factor": [1.1, 1.2, 1.3, 1.4, 1.5, 1.6],
+    }
+    b = DataFrame(b).set_index(["Cat", "Int"])["Factor"]
+
+    expected = merge(
+        a,
+        b.reset_index(),
+        left_on=["Cat1", "Int1"],
+        right_on=["Cat", "Int"],
+        how="left",
+    )
+    expected = expected.drop(["Cat", "Int"], axis=1)
+    result = a.join(b, on=["Cat1", "Int1"])
+    tm.assert_frame_equal(expected, result)
+
+
+@pytest.mark.parametrize("func", ["merge", "merge_asof"])
+@pytest.mark.parametrize(
+    ("kwargs", "err_msg"),
+    [
+        ({"left_on": "a", "left_index": True}, ["left_on", "left_index"]),
+        ({"right_on": "a", "right_index": True}, ["right_on", "right_index"]),
+    ],
+)
+def test_merge_join_cols_error_reporting_duplicates(func, kwargs, err_msg):
+    # GH: 16228
+    left = DataFrame({"a": [1, 2], "b": [3, 4]})
+    right = DataFrame({"a": [1, 1], "c": [5, 6]})
+    msg = rf'Can only pass argument "{err_msg[0]}" OR "{err_msg[1]}" not both\.'
+    with pytest.raises(MergeError, match=msg):
+        getattr(pd, func)(left, right, **kwargs)
+
+
+@pytest.mark.parametrize("func", ["merge", "merge_asof"])
+@pytest.mark.parametrize(
+    ("kwargs", "err_msg"),
+    [
+        ({"left_on": "a"}, ["right_on", "right_index"]),
+        ({"right_on": "a"}, ["left_on", "left_index"]),
+    ],
+)
+def test_merge_join_cols_error_reporting_missing(func, kwargs, err_msg):
+    # GH: 16228
+    left = DataFrame({"a": [1, 2], "b": [3, 4]})
+    right = DataFrame({"a": [1, 1], "c": [5, 6]})
+    msg = rf'Must pass "{err_msg[0]}" OR "{err_msg[1]}"\.'
+    with pytest.raises(MergeError, match=msg):
+        getattr(pd, func)(left, right, **kwargs)
+
+
+@pytest.mark.parametrize("func", ["merge", "merge_asof"])
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"right_index": True},
+        {"left_index": True},
+    ],
+)
+def test_merge_join_cols_error_reporting_on_and_index(func, kwargs):
+    # GH: 16228
+    left = DataFrame({"a": [1, 2], "b": [3, 4]})
+    right = DataFrame({"a": [1, 1], "c": [5, 6]})
+    msg = (
+        r'Can only pass argument "on" OR "left_index" '
+        r'and "right_index", not a combination of both\.'
+    )
+    with pytest.raises(MergeError, match=msg):
+        getattr(pd, func)(left, right, on="a", **kwargs)
+
+
+def test_merge_right_left_index():
+    # GH#38616
+    left = DataFrame({"x": [1, 1], "z": ["foo", "foo"]})
+    right = DataFrame({"x": [1, 1], "z": ["foo", "foo"]})
+    result = merge(left, right, how="right", left_index=True, right_on="x")
+    expected = DataFrame(
+        {
+            "x": [1, 1],
+            "x_x": [1, 1],
+            "z_x": ["foo", "foo"],
+            "x_y": [1, 1],
+            "z_y": ["foo", "foo"],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_result_empty_index_and_on():
+    # GH#33814
+    df1 = DataFrame({"a": [1], "b": [2]}).set_index(["a", "b"])
+    df2 = DataFrame({"b": [1]}).set_index(["b"])
+    expected = DataFrame({"a": [], "b": []}, dtype=np.int64).set_index(["a", "b"])
+    result = merge(df1, df2, left_on=["b"], right_index=True)
+    tm.assert_frame_equal(result, expected)
+
+    result = merge(df2, df1, left_index=True, right_on=["b"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_suffixes_produce_dup_columns_raises():
+    # GH#22818; Enforced in 2.0
+    left = DataFrame({"a": [1, 2, 3], "b": 1, "b_x": 2})
+    right = DataFrame({"a": [1, 2, 3], "b": 2})
+
+    with pytest.raises(MergeError, match="Passing 'suffixes' which cause duplicate"):
+        merge(left, right, on="a")
+
+    with pytest.raises(MergeError, match="Passing 'suffixes' which cause duplicate"):
+        merge(right, left, on="a", suffixes=("_y", "_x"))
+
+
+def test_merge_duplicate_columns_with_suffix_no_warning():
+    # GH#22818
+    # Do not raise warning when duplicates are caused by duplicates in origin
+    left = DataFrame([[1, 1, 1], [2, 2, 2]], columns=["a", "b", "b"])
+    right = DataFrame({"a": [1, 3], "b": 2})
+    result = merge(left, right, on="a")
+    expected = DataFrame([[1, 1, 1, 2]], columns=["a", "b_x", "b_x", "b_y"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_duplicate_columns_with_suffix_causing_another_duplicate_raises():
+    # GH#22818, Enforced in 2.0
+    # This should raise warning because suffixes cause another collision
+    left = DataFrame([[1, 1, 1, 1], [2, 2, 2, 2]], columns=["a", "b", "b", "b_x"])
+    right = DataFrame({"a": [1, 3], "b": 2})
+    with pytest.raises(MergeError, match="Passing 'suffixes' which cause duplicate"):
+        merge(left, right, on="a")
+
+
+def test_merge_string_float_column_result():
+    # GH 13353
+    df1 = DataFrame([[1, 2], [3, 4]], columns=Index(["a", 114.0]))
+    df2 = DataFrame([[9, 10], [11, 12]], columns=["x", "y"])
+    result = merge(df2, df1, how="inner", left_index=True, right_index=True)
+    expected = DataFrame(
+        [[9, 10, 1, 2], [11, 12, 3, 4]], columns=Index(["x", "y", "a", 114.0])
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_mergeerror_on_left_index_mismatched_dtypes():
+    # GH 22449
+    df_1 = DataFrame(data=["X"], columns=["C"], index=[22])
+    df_2 = DataFrame(data=["X"], columns=["C"], index=[999])
+    with pytest.raises(MergeError, match="Can only pass argument"):
+        merge(df_1, df_2, on=["C"], left_index=True)
+
+
+def test_merge_on_left_categoricalindex():
+    # GH#48464 don't raise when left_on is a CategoricalIndex
+    ci = CategoricalIndex(range(3))
+
+    right = DataFrame({"A": ci, "B": range(3)})
+    left = DataFrame({"C": range(3, 6)})
+
+    res = merge(left, right, left_on=ci, right_on="A")
+    expected = merge(left, right, left_on=ci._data, right_on="A")
+    tm.assert_frame_equal(res, expected)
+
+
+@pytest.mark.parametrize("dtype", [None, "Int64"])
+def test_merge_outer_with_NaN(dtype):
+    # GH#43550
+    left = DataFrame({"key": [1, 2], "col1": [1, 2]}, dtype=dtype)
+    right = DataFrame({"key": [np.nan, np.nan], "col2": [3, 4]}, dtype=dtype)
+    result = merge(left, right, on="key", how="outer")
+    expected = DataFrame(
+        {
+            "key": [1, 2, np.nan, np.nan],
+            "col1": [1, 2, np.nan, np.nan],
+            "col2": [np.nan, np.nan, 3, 4],
+        },
+        dtype=dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # switch left and right
+    result = merge(right, left, on="key", how="outer")
+    expected = DataFrame(
+        {
+            "key": [np.nan, np.nan, 1, 2],
+            "col2": [3, 4, np.nan, np.nan],
+            "col1": [np.nan, np.nan, 1, 2],
+        },
+        dtype=dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_different_index_names():
+    # GH#45094
+    left = DataFrame({"a": [1]}, index=Index([1], name="c"))
+    right = DataFrame({"a": [1]}, index=Index([1], name="d"))
+    result = merge(left, right, left_on="c", right_on="d")
+    expected = DataFrame({"a_x": [1], "a_y": 1})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_ea(any_numeric_ea_dtype, join_type):
+    # GH#44240
+    left = DataFrame({"a": [1, 2, 3], "b": 1}, dtype=any_numeric_ea_dtype)
+    right = DataFrame({"a": [1, 2, 3], "c": 2}, dtype=any_numeric_ea_dtype)
+    result = left.merge(right, how=join_type)
+    expected = DataFrame({"a": [1, 2, 3], "b": 1, "c": 2}, dtype=any_numeric_ea_dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_ea_and_non_ea(any_numeric_ea_dtype, join_type):
+    # GH#44240
+    left = DataFrame({"a": [1, 2, 3], "b": 1}, dtype=any_numeric_ea_dtype)
+    right = DataFrame({"a": [1, 2, 3], "c": 2}, dtype=any_numeric_ea_dtype.lower())
+    result = left.merge(right, how=join_type)
+    expected = DataFrame(
+        {
+            "a": Series([1, 2, 3], dtype=any_numeric_ea_dtype),
+            "b": Series([1, 1, 1], dtype=any_numeric_ea_dtype),
+            "c": Series([2, 2, 2], dtype=any_numeric_ea_dtype.lower()),
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["int64", "int64[pyarrow]"])
+def test_merge_arrow_and_numpy_dtypes(dtype):
+    # GH#52406
+    pytest.importorskip("pyarrow")
+    df = DataFrame({"a": [1, 2]}, dtype=dtype)
+    df2 = DataFrame({"a": [1, 2]}, dtype="int64[pyarrow]")
+    result = df.merge(df2)
+    expected = df.copy()
+    tm.assert_frame_equal(result, expected)
+
+    result = df2.merge(df)
+    expected = df2.copy()
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("how", ["inner", "left", "outer", "right"])
+@pytest.mark.parametrize("tz", [None, "America/Chicago"])
+def test_merge_datetime_different_resolution(tz, how):
+    # https://github.com/pandas-dev/pandas/issues/53200
+    vals = [
+        pd.Timestamp(2023, 5, 12, tz=tz),
+        pd.Timestamp(2023, 5, 13, tz=tz),
+        pd.Timestamp(2023, 5, 14, tz=tz),
+    ]
+    df1 = DataFrame({"t": vals[:2], "a": [1.0, 2.0]})
+    df1["t"] = df1["t"].dt.as_unit("ns")
+    df2 = DataFrame({"t": vals[1:], "b": [1.0, 2.0]})
+    df2["t"] = df2["t"].dt.as_unit("s")
+
+    expected = DataFrame({"t": vals, "a": [1.0, 2.0, np.nan], "b": [np.nan, 1.0, 2.0]})
+    expected["t"] = expected["t"].dt.as_unit("ns")
+    if how == "inner":
+        expected = expected.iloc[[1]].reset_index(drop=True)
+    elif how == "left":
+        expected = expected.iloc[[0, 1]]
+    elif how == "right":
+        expected = expected.iloc[[1, 2]].reset_index(drop=True)
+
+    result = df1.merge(df2, on="t", how=how)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_multiindex_single_level():
+    # GH52331
+    df = DataFrame({"col": ["A", "B"]})
+    df2 = DataFrame(
+        data={"b": [100]},
+        index=MultiIndex.from_tuples([("A",), ("C",)], names=["col"]),
+    )
+    expected = DataFrame({"col": ["A", "B"], "b": [100, np.nan]})
+
+    result = df.merge(df2, left_on=["col"], right_index=True, how="left")
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_ea_int_and_float_numpy():
+    # GH#46178
+    df1 = DataFrame([1.0, np.nan], dtype=pd.Int64Dtype())
+    df2 = DataFrame([1.5])
+    expected = DataFrame(columns=[0], dtype="Int64")
+
+    with tm.assert_produces_warning(UserWarning, match="You are merging"):
+        result = df1.merge(df2)
+    tm.assert_frame_equal(result, expected)
+
+    with tm.assert_produces_warning(UserWarning, match="You are merging"):
+        result = df2.merge(df1)
+    tm.assert_frame_equal(result, expected.astype("float64"))
+
+    df2 = DataFrame([1.0])
+    expected = DataFrame([1], columns=[0], dtype="Int64")
+    result = df1.merge(df2)
+    tm.assert_frame_equal(result, expected)
+
+    result = df2.merge(df1)
+    tm.assert_frame_equal(result, expected.astype("float64"))
+
+
+def test_merge_arrow_string_index(any_string_dtype):
+    # GH#54894
+    pytest.importorskip("pyarrow")
+    left = DataFrame({"a": ["a", "b"]}, dtype=any_string_dtype)
+    right = DataFrame({"b": 1}, index=Index(["a", "c"], dtype=any_string_dtype))
+    result = left.merge(right, left_on="a", right_index=True, how="left")
+    expected = DataFrame(
+        {"a": Series(["a", "b"], dtype=any_string_dtype), "b": [1, np.nan]}
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_asof.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_asof.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4ae81f86513cb943520c776093d71b7b122127a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_asof.py
@@ -0,0 +1,1696 @@
+import datetime
+
+import numpy as np
+import pytest
+import pytz
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    Index,
+    Timedelta,
+    merge_asof,
+    read_csv,
+    to_datetime,
+)
+import pandas._testing as tm
+from pandas.core.reshape.merge import MergeError
+
+
+@pytest.fixture(params=["s", "ms", "us", "ns"])
+def unit(request):
+    """
+    Resolution for datetimelike dtypes.
+    """
+    return request.param
+
+
+class TestAsOfMerge:
+    def read_data(self, datapath, name, dedupe=False):
+        path = datapath("reshape", "merge", "data", name)
+        x = read_csv(path)
+        if dedupe:
+            x = x.drop_duplicates(["time", "ticker"], keep="last").reset_index(
+                drop=True
+            )
+        x.time = to_datetime(x.time)
+        return x
+
+    @pytest.fixture
+    def trades(self, datapath):
+        return self.read_data(datapath, "trades.csv")
+
+    @pytest.fixture
+    def quotes(self, datapath):
+        return self.read_data(datapath, "quotes.csv", dedupe=True)
+
+    @pytest.fixture
+    def asof(self, datapath):
+        return self.read_data(datapath, "asof.csv")
+
+    @pytest.fixture
+    def tolerance(self, datapath):
+        return self.read_data(datapath, "tolerance.csv")
+
+    @pytest.fixture
+    def allow_exact_matches(self, datapath):
+        return self.read_data(datapath, "allow_exact_matches.csv")
+
+    @pytest.fixture
+    def allow_exact_matches_and_tolerance(self, datapath):
+        return self.read_data(datapath, "allow_exact_matches_and_tolerance.csv")
+
+    def test_examples1(self):
+        """doc-string examples"""
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 6, 7], "right_val": [1, 2, 3, 6, 7]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, 3, 7]}
+        )
+
+        result = merge_asof(left, right, on="a")
+        tm.assert_frame_equal(result, expected)
+
+    def test_examples2(self, unit):
+        """doc-string examples"""
+        if unit == "s":
+            pytest.skip(
+                "This test is invalid for unit='s' because that would "
+                "round the trades['time']]"
+            )
+        trades = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.038",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.048",
+                    ]
+                ).astype(f"M8[{unit}]"),
+                "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
+                "price": [51.95, 51.95, 720.77, 720.92, 98.00],
+                "quantity": [75, 155, 100, 100, 100],
+            },
+            columns=["time", "ticker", "price", "quantity"],
+        )
+
+        quotes = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.030",
+                        "20160525 13:30:00.041",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.049",
+                        "20160525 13:30:00.072",
+                        "20160525 13:30:00.075",
+                    ]
+                ).astype(f"M8[{unit}]"),
+                "ticker": [
+                    "GOOG",
+                    "MSFT",
+                    "MSFT",
+                    "MSFT",
+                    "GOOG",
+                    "AAPL",
+                    "GOOG",
+                    "MSFT",
+                ],
+                "bid": [720.50, 51.95, 51.97, 51.99, 720.50, 97.99, 720.50, 52.01],
+                "ask": [720.93, 51.96, 51.98, 52.00, 720.93, 98.01, 720.88, 52.03],
+            },
+            columns=["time", "ticker", "bid", "ask"],
+        )
+
+        merge_asof(trades, quotes, on="time", by="ticker")
+
+        merge_asof(trades, quotes, on="time", by="ticker", tolerance=Timedelta("2ms"))
+
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.038",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.048",
+                    ]
+                ).astype(f"M8[{unit}]"),
+                "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
+                "price": [51.95, 51.95, 720.77, 720.92, 98.00],
+                "quantity": [75, 155, 100, 100, 100],
+                "bid": [np.nan, 51.97, np.nan, np.nan, np.nan],
+                "ask": [np.nan, 51.98, np.nan, np.nan, np.nan],
+            },
+            columns=["time", "ticker", "price", "quantity", "bid", "ask"],
+        )
+
+        result = merge_asof(
+            trades,
+            quotes,
+            on="time",
+            by="ticker",
+            tolerance=Timedelta("10ms"),
+            allow_exact_matches=False,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_examples3(self):
+        """doc-string examples"""
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 6, 7], "right_val": [1, 2, 3, 6, 7]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, 6, np.nan]}
+        )
+
+        result = merge_asof(left, right, on="a", direction="forward")
+        tm.assert_frame_equal(result, expected)
+
+    def test_examples4(self):
+        """doc-string examples"""
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 6, 7], "right_val": [1, 2, 3, 6, 7]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, 6, 7]}
+        )
+
+        result = merge_asof(left, right, on="a", direction="nearest")
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic(self, trades, asof, quotes):
+        expected = asof
+
+        result = merge_asof(trades, quotes, on="time", by="ticker")
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic_categorical(self, trades, asof, quotes):
+        expected = asof
+        trades.ticker = trades.ticker.astype("category")
+        quotes.ticker = quotes.ticker.astype("category")
+        expected.ticker = expected.ticker.astype("category")
+
+        result = merge_asof(trades, quotes, on="time", by="ticker")
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic_left_index(self, trades, asof, quotes):
+        # GH14253
+        expected = asof
+        trades = trades.set_index("time")
+
+        result = merge_asof(
+            trades, quotes, left_index=True, right_on="time", by="ticker"
+        )
+        # left-only index uses right"s index, oddly
+        expected.index = result.index
+        # time column appears after left"s columns
+        expected = expected[result.columns]
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic_right_index(self, trades, asof, quotes):
+        expected = asof
+        quotes = quotes.set_index("time")
+
+        result = merge_asof(
+            trades, quotes, left_on="time", right_index=True, by="ticker"
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic_left_index_right_index(self, trades, asof, quotes):
+        expected = asof.set_index("time")
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
+
+        result = merge_asof(
+            trades, quotes, left_index=True, right_index=True, by="ticker"
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_multi_index_left(self, trades, quotes):
+        # MultiIndex is prohibited
+        trades = trades.set_index(["time", "price"])
+        quotes = quotes.set_index("time")
+        with pytest.raises(MergeError, match="left can only have one index"):
+            merge_asof(trades, quotes, left_index=True, right_index=True)
+
+    def test_multi_index_right(self, trades, quotes):
+        # MultiIndex is prohibited
+        trades = trades.set_index("time")
+        quotes = quotes.set_index(["time", "bid"])
+        with pytest.raises(MergeError, match="right can only have one index"):
+            merge_asof(trades, quotes, left_index=True, right_index=True)
+
+    def test_on_and_index_left_on(self, trades, quotes):
+        # "on" parameter and index together is prohibited
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
+        msg = 'Can only pass argument "left_on" OR "left_index" not both.'
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(
+                trades, quotes, left_on="price", left_index=True, right_index=True
+            )
+
+    def test_on_and_index_right_on(self, trades, quotes):
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
+        msg = 'Can only pass argument "right_on" OR "right_index" not both.'
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(
+                trades, quotes, right_on="bid", left_index=True, right_index=True
+            )
+
+    def test_basic_left_by_right_by(self, trades, asof, quotes):
+        # GH14253
+        expected = asof
+
+        result = merge_asof(
+            trades, quotes, on="time", left_by="ticker", right_by="ticker"
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing_right_by(self, trades, asof, quotes):
+        expected = asof
+
+        q = quotes[quotes.ticker != "MSFT"]
+        result = merge_asof(trades, q, on="time", by="ticker")
+        expected.loc[expected.ticker == "MSFT", ["bid", "ask"]] = np.nan
+        tm.assert_frame_equal(result, expected)
+
+    def test_multiby(self):
+        # GH13936
+        trades = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.046",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.050",
+                    ]
+                ),
+                "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
+                "exch": ["ARCA", "NSDQ", "NSDQ", "BATS", "NSDQ"],
+                "price": [51.95, 51.95, 720.77, 720.92, 98.00],
+                "quantity": [75, 155, 100, 100, 100],
+            },
+            columns=["time", "ticker", "exch", "price", "quantity"],
+        )
+
+        quotes = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.030",
+                        "20160525 13:30:00.041",
+                        "20160525 13:30:00.045",
+                        "20160525 13:30:00.049",
+                    ]
+                ),
+                "ticker": ["GOOG", "MSFT", "MSFT", "MSFT", "GOOG", "AAPL"],
+                "exch": ["BATS", "NSDQ", "ARCA", "ARCA", "NSDQ", "ARCA"],
+                "bid": [720.51, 51.95, 51.97, 51.99, 720.50, 97.99],
+                "ask": [720.92, 51.96, 51.98, 52.00, 720.93, 98.01],
+            },
+            columns=["time", "ticker", "exch", "bid", "ask"],
+        )
+
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.046",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.050",
+                    ]
+                ),
+                "ticker": ["MSFT", "MSFT", "GOOG", "GOOG", "AAPL"],
+                "exch": ["ARCA", "NSDQ", "NSDQ", "BATS", "NSDQ"],
+                "price": [51.95, 51.95, 720.77, 720.92, 98.00],
+                "quantity": [75, 155, 100, 100, 100],
+                "bid": [np.nan, 51.95, 720.50, 720.51, np.nan],
+                "ask": [np.nan, 51.96, 720.93, 720.92, np.nan],
+            },
+            columns=["time", "ticker", "exch", "price", "quantity", "bid", "ask"],
+        )
+
+        result = merge_asof(trades, quotes, on="time", by=["ticker", "exch"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_multiby_heterogeneous_types(self):
+        # GH13936
+        trades = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.046",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.050",
+                    ]
+                ),
+                "ticker": [0, 0, 1, 1, 2],
+                "exch": ["ARCA", "NSDQ", "NSDQ", "BATS", "NSDQ"],
+                "price": [51.95, 51.95, 720.77, 720.92, 98.00],
+                "quantity": [75, 155, 100, 100, 100],
+            },
+            columns=["time", "ticker", "exch", "price", "quantity"],
+        )
+
+        quotes = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.030",
+                        "20160525 13:30:00.041",
+                        "20160525 13:30:00.045",
+                        "20160525 13:30:00.049",
+                    ]
+                ),
+                "ticker": [1, 0, 0, 0, 1, 2],
+                "exch": ["BATS", "NSDQ", "ARCA", "ARCA", "NSDQ", "ARCA"],
+                "bid": [720.51, 51.95, 51.97, 51.99, 720.50, 97.99],
+                "ask": [720.92, 51.96, 51.98, 52.00, 720.93, 98.01],
+            },
+            columns=["time", "ticker", "exch", "bid", "ask"],
+        )
+
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.023",
+                        "20160525 13:30:00.046",
+                        "20160525 13:30:00.048",
+                        "20160525 13:30:00.050",
+                    ]
+                ),
+                "ticker": [0, 0, 1, 1, 2],
+                "exch": ["ARCA", "NSDQ", "NSDQ", "BATS", "NSDQ"],
+                "price": [51.95, 51.95, 720.77, 720.92, 98.00],
+                "quantity": [75, 155, 100, 100, 100],
+                "bid": [np.nan, 51.95, 720.50, 720.51, np.nan],
+                "ask": [np.nan, 51.96, 720.93, 720.92, np.nan],
+            },
+            columns=["time", "ticker", "exch", "price", "quantity", "bid", "ask"],
+        )
+
+        result = merge_asof(trades, quotes, on="time", by=["ticker", "exch"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_mismatched_index_dtype(self):
+        # similar to test_multiby_indexed, but we change the dtype on left.index
+        left = pd.DataFrame(
+            [
+                [to_datetime("20160602"), 1, "a"],
+                [to_datetime("20160602"), 2, "a"],
+                [to_datetime("20160603"), 1, "b"],
+                [to_datetime("20160603"), 2, "b"],
+            ],
+            columns=["time", "k1", "k2"],
+        ).set_index("time")
+        # different dtype for the index
+        left.index = left.index - pd.Timestamp(0)
+
+        right = pd.DataFrame(
+            [
+                [to_datetime("20160502"), 1, "a", 1.0],
+                [to_datetime("20160502"), 2, "a", 2.0],
+                [to_datetime("20160503"), 1, "b", 3.0],
+                [to_datetime("20160503"), 2, "b", 4.0],
+            ],
+            columns=["time", "k1", "k2", "value"],
+        ).set_index("time")
+
+        msg = "incompatible merge keys"
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(left, right, left_index=True, right_index=True, by=["k1", "k2"])
+
+    def test_multiby_indexed(self):
+        # GH15676
+        left = pd.DataFrame(
+            [
+                [to_datetime("20160602"), 1, "a"],
+                [to_datetime("20160602"), 2, "a"],
+                [to_datetime("20160603"), 1, "b"],
+                [to_datetime("20160603"), 2, "b"],
+            ],
+            columns=["time", "k1", "k2"],
+        ).set_index("time")
+
+        right = pd.DataFrame(
+            [
+                [to_datetime("20160502"), 1, "a", 1.0],
+                [to_datetime("20160502"), 2, "a", 2.0],
+                [to_datetime("20160503"), 1, "b", 3.0],
+                [to_datetime("20160503"), 2, "b", 4.0],
+            ],
+            columns=["time", "k1", "k2", "value"],
+        ).set_index("time")
+
+        expected = pd.DataFrame(
+            [
+                [to_datetime("20160602"), 1, "a", 1.0],
+                [to_datetime("20160602"), 2, "a", 2.0],
+                [to_datetime("20160603"), 1, "b", 3.0],
+                [to_datetime("20160603"), 2, "b", 4.0],
+            ],
+            columns=["time", "k1", "k2", "value"],
+        ).set_index("time")
+
+        result = merge_asof(
+            left, right, left_index=True, right_index=True, by=["k1", "k2"]
+        )
+
+        tm.assert_frame_equal(expected, result)
+
+        with pytest.raises(
+            MergeError, match="left_by and right_by must be the same length"
+        ):
+            merge_asof(
+                left,
+                right,
+                left_index=True,
+                right_index=True,
+                left_by=["k1", "k2"],
+                right_by=["k1"],
+            )
+
+    def test_basic2(self, datapath):
+        expected = self.read_data(datapath, "asof2.csv")
+        trades = self.read_data(datapath, "trades2.csv")
+        quotes = self.read_data(datapath, "quotes2.csv", dedupe=True)
+
+        result = merge_asof(trades, quotes, on="time", by="ticker")
+        tm.assert_frame_equal(result, expected)
+
+    def test_basic_no_by(self, trades, asof, quotes):
+        f = (
+            lambda x: x[x.ticker == "MSFT"]
+            .drop("ticker", axis=1)
+            .reset_index(drop=True)
+        )
+
+        # just use a single ticker
+        expected = f(asof)
+        trades = f(trades)
+        quotes = f(quotes)
+
+        result = merge_asof(trades, quotes, on="time")
+        tm.assert_frame_equal(result, expected)
+
+    def test_valid_join_keys(self, trades, quotes):
+        msg = r"incompatible merge keys \[1\] .* must be the same type"
+
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(trades, quotes, left_on="time", right_on="bid", by="ticker")
+
+        with pytest.raises(MergeError, match="can only asof on a key for left"):
+            merge_asof(trades, quotes, on=["time", "ticker"], by="ticker")
+
+        with pytest.raises(MergeError, match="can only asof on a key for left"):
+            merge_asof(trades, quotes, by="ticker")
+
+    def test_with_duplicates(self, datapath, trades, quotes):
+        q = (
+            pd.concat([quotes, quotes])
+            .sort_values(["time", "ticker"])
+            .reset_index(drop=True)
+        )
+        result = merge_asof(trades, q, on="time", by="ticker")
+        expected = self.read_data(datapath, "asof.csv")
+        tm.assert_frame_equal(result, expected)
+
+    def test_with_duplicates_no_on(self):
+        df1 = pd.DataFrame({"key": [1, 1, 3], "left_val": [1, 2, 3]})
+        df2 = pd.DataFrame({"key": [1, 2, 2], "right_val": [1, 2, 3]})
+        result = merge_asof(df1, df2, on="key")
+        expected = pd.DataFrame(
+            {"key": [1, 1, 3], "left_val": [1, 2, 3], "right_val": [1, 1, 3]}
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_valid_allow_exact_matches(self, trades, quotes):
+        msg = "allow_exact_matches must be boolean, passed foo"
+
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(
+                trades, quotes, on="time", by="ticker", allow_exact_matches="foo"
+            )
+
+    def test_valid_tolerance(self, trades, quotes):
+        # dti
+        merge_asof(trades, quotes, on="time", by="ticker", tolerance=Timedelta("1s"))
+
+        # integer
+        merge_asof(
+            trades.reset_index(),
+            quotes.reset_index(),
+            on="index",
+            by="ticker",
+            tolerance=1,
+        )
+
+        msg = r"incompatible tolerance .*, must be compat with type .*"
+
+        # incompat
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(trades, quotes, on="time", by="ticker", tolerance=1)
+
+        # invalid
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(
+                trades.reset_index(),
+                quotes.reset_index(),
+                on="index",
+                by="ticker",
+                tolerance=1.0,
+            )
+
+        msg = "tolerance must be positive"
+
+        # invalid negative
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(
+                trades, quotes, on="time", by="ticker", tolerance=-Timedelta("1s")
+            )
+
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(
+                trades.reset_index(),
+                quotes.reset_index(),
+                on="index",
+                by="ticker",
+                tolerance=-1,
+            )
+
+    def test_non_sorted(self, trades, quotes):
+        trades = trades.sort_values("time", ascending=False)
+        quotes = quotes.sort_values("time", ascending=False)
+
+        # we require that we are already sorted on time & quotes
+        assert not trades.time.is_monotonic_increasing
+        assert not quotes.time.is_monotonic_increasing
+        with pytest.raises(ValueError, match="left keys must be sorted"):
+            merge_asof(trades, quotes, on="time", by="ticker")
+
+        trades = trades.sort_values("time")
+        assert trades.time.is_monotonic_increasing
+        assert not quotes.time.is_monotonic_increasing
+        with pytest.raises(ValueError, match="right keys must be sorted"):
+            merge_asof(trades, quotes, on="time", by="ticker")
+
+        quotes = quotes.sort_values("time")
+        assert trades.time.is_monotonic_increasing
+        assert quotes.time.is_monotonic_increasing
+
+        # ok, though has dupes
+        merge_asof(trades, quotes, on="time", by="ticker")
+
+    @pytest.mark.parametrize(
+        "tolerance_ts",
+        [Timedelta("1day"), datetime.timedelta(days=1)],
+        ids=["Timedelta", "datetime.timedelta"],
+    )
+    def test_tolerance(self, tolerance_ts, trades, quotes, tolerance):
+        result = merge_asof(
+            trades, quotes, on="time", by="ticker", tolerance=tolerance_ts
+        )
+        expected = tolerance
+        tm.assert_frame_equal(result, expected)
+
+    def test_tolerance_forward(self):
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 7, 11], "right_val": [1, 2, 3, 7, 11]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, np.nan, 11]}
+        )
+
+        result = merge_asof(left, right, on="a", direction="forward", tolerance=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_tolerance_nearest(self):
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 7, 11], "right_val": [1, 2, 3, 7, 11]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, np.nan, 11]}
+        )
+
+        result = merge_asof(left, right, on="a", direction="nearest", tolerance=1)
+        tm.assert_frame_equal(result, expected)
+
+    def test_tolerance_tz(self, unit):
+        # GH 14844
+        left = pd.DataFrame(
+            {
+                "date": pd.date_range(
+                    start=to_datetime("2016-01-02"),
+                    freq="D",
+                    periods=5,
+                    tz=pytz.timezone("UTC"),
+                    unit=unit,
+                ),
+                "value1": np.arange(5),
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "date": pd.date_range(
+                    start=to_datetime("2016-01-01"),
+                    freq="D",
+                    periods=5,
+                    tz=pytz.timezone("UTC"),
+                    unit=unit,
+                ),
+                "value2": list("ABCDE"),
+            }
+        )
+        result = merge_asof(left, right, on="date", tolerance=Timedelta("1 day"))
+
+        expected = pd.DataFrame(
+            {
+                "date": pd.date_range(
+                    start=to_datetime("2016-01-02"),
+                    freq="D",
+                    periods=5,
+                    tz=pytz.timezone("UTC"),
+                    unit=unit,
+                ),
+                "value1": np.arange(5),
+                "value2": list("BCDEE"),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_tolerance_float(self):
+        # GH22981
+        left = pd.DataFrame({"a": [1.1, 3.5, 10.9], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame(
+            {"a": [1.0, 2.5, 3.3, 7.5, 11.5], "right_val": [1.0, 2.5, 3.3, 7.5, 11.5]}
+        )
+
+        expected = pd.DataFrame(
+            {
+                "a": [1.1, 3.5, 10.9],
+                "left_val": ["a", "b", "c"],
+                "right_val": [1, 3.3, np.nan],
+            }
+        )
+
+        result = merge_asof(left, right, on="a", direction="nearest", tolerance=0.5)
+        tm.assert_frame_equal(result, expected)
+
+    def test_index_tolerance(self, trades, quotes, tolerance):
+        # GH 15135
+        expected = tolerance.set_index("time")
+        trades = trades.set_index("time")
+        quotes = quotes.set_index("time")
+
+        result = merge_asof(
+            trades,
+            quotes,
+            left_index=True,
+            right_index=True,
+            by="ticker",
+            tolerance=Timedelta("1day"),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches(self, trades, quotes, allow_exact_matches):
+        result = merge_asof(
+            trades, quotes, on="time", by="ticker", allow_exact_matches=False
+        )
+        expected = allow_exact_matches
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_forward(self):
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 7, 11], "right_val": [1, 2, 3, 7, 11]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [2, 7, 11]}
+        )
+
+        result = merge_asof(
+            left, right, on="a", direction="forward", allow_exact_matches=False
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_nearest(self):
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 2, 3, 7, 11], "right_val": [1, 2, 3, 7, 11]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [2, 3, 11]}
+        )
+
+        result = merge_asof(
+            left, right, on="a", direction="nearest", allow_exact_matches=False
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_and_tolerance(
+        self, trades, quotes, allow_exact_matches_and_tolerance
+    ):
+        result = merge_asof(
+            trades,
+            quotes,
+            on="time",
+            by="ticker",
+            tolerance=Timedelta("100ms"),
+            allow_exact_matches=False,
+        )
+        expected = allow_exact_matches_and_tolerance
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_and_tolerance2(self):
+        # GH 13695
+        df1 = pd.DataFrame(
+            {"time": to_datetime(["2016-07-15 13:30:00.030"]), "username": ["bob"]}
+        )
+        df2 = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    ["2016-07-15 13:30:00.000", "2016-07-15 13:30:00.030"]
+                ),
+                "version": [1, 2],
+            }
+        )
+
+        result = merge_asof(df1, df2, on="time")
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(["2016-07-15 13:30:00.030"]),
+                "username": ["bob"],
+                "version": [2],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = merge_asof(df1, df2, on="time", allow_exact_matches=False)
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(["2016-07-15 13:30:00.030"]),
+                "username": ["bob"],
+                "version": [1],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = merge_asof(
+            df1,
+            df2,
+            on="time",
+            allow_exact_matches=False,
+            tolerance=Timedelta("10ms"),
+        )
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(["2016-07-15 13:30:00.030"]),
+                "username": ["bob"],
+                "version": [np.nan],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_and_tolerance3(self):
+        # GH 13709
+        df1 = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    ["2016-07-15 13:30:00.030", "2016-07-15 13:30:00.030"]
+                ),
+                "username": ["bob", "charlie"],
+            }
+        )
+        df2 = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    ["2016-07-15 13:30:00.000", "2016-07-15 13:30:00.030"]
+                ),
+                "version": [1, 2],
+            }
+        )
+
+        result = merge_asof(
+            df1,
+            df2,
+            on="time",
+            allow_exact_matches=False,
+            tolerance=Timedelta("10ms"),
+        )
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    ["2016-07-15 13:30:00.030", "2016-07-15 13:30:00.030"]
+                ),
+                "username": ["bob", "charlie"],
+                "version": [np.nan, np.nan],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_and_tolerance_forward(self):
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 3, 4, 6, 11], "right_val": [1, 3, 4, 6, 11]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [np.nan, 6, 11]}
+        )
+
+        result = merge_asof(
+            left,
+            right,
+            on="a",
+            direction="forward",
+            allow_exact_matches=False,
+            tolerance=1,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_allow_exact_matches_and_tolerance_nearest(self):
+        # GH14887
+
+        left = pd.DataFrame({"a": [1, 5, 10], "left_val": ["a", "b", "c"]})
+        right = pd.DataFrame({"a": [1, 3, 4, 6, 11], "right_val": [1, 3, 4, 7, 11]})
+
+        expected = pd.DataFrame(
+            {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [np.nan, 4, 11]}
+        )
+
+        result = merge_asof(
+            left,
+            right,
+            on="a",
+            direction="nearest",
+            allow_exact_matches=False,
+            tolerance=1,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_forward_by(self):
+        # GH14887
+
+        left = pd.DataFrame(
+            {
+                "a": [1, 5, 10, 12, 15],
+                "b": ["X", "X", "Y", "Z", "Y"],
+                "left_val": ["a", "b", "c", "d", "e"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "a": [1, 6, 11, 15, 16],
+                "b": ["X", "Z", "Y", "Z", "Y"],
+                "right_val": [1, 6, 11, 15, 16],
+            }
+        )
+
+        expected = pd.DataFrame(
+            {
+                "a": [1, 5, 10, 12, 15],
+                "b": ["X", "X", "Y", "Z", "Y"],
+                "left_val": ["a", "b", "c", "d", "e"],
+                "right_val": [1, np.nan, 11, 15, 16],
+            }
+        )
+
+        result = merge_asof(left, right, on="a", by="b", direction="forward")
+        tm.assert_frame_equal(result, expected)
+
+    def test_nearest_by(self):
+        # GH14887
+
+        left = pd.DataFrame(
+            {
+                "a": [1, 5, 10, 12, 15],
+                "b": ["X", "X", "Z", "Z", "Y"],
+                "left_val": ["a", "b", "c", "d", "e"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "a": [1, 6, 11, 15, 16],
+                "b": ["X", "Z", "Z", "Z", "Y"],
+                "right_val": [1, 6, 11, 15, 16],
+            }
+        )
+
+        expected = pd.DataFrame(
+            {
+                "a": [1, 5, 10, 12, 15],
+                "b": ["X", "X", "Z", "Z", "Y"],
+                "left_val": ["a", "b", "c", "d", "e"],
+                "right_val": [1, 1, 11, 11, 16],
+            }
+        )
+
+        result = merge_asof(left, right, on="a", by="b", direction="nearest")
+        tm.assert_frame_equal(result, expected)
+
+    def test_by_int(self):
+        # we specialize by type, so test that this is correct
+        df1 = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.020",
+                        "20160525 13:30:00.030",
+                        "20160525 13:30:00.040",
+                        "20160525 13:30:00.050",
+                        "20160525 13:30:00.060",
+                    ]
+                ),
+                "key": [1, 2, 1, 3, 2],
+                "value1": [1.1, 1.2, 1.3, 1.4, 1.5],
+            },
+            columns=["time", "key", "value1"],
+        )
+
+        df2 = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.015",
+                        "20160525 13:30:00.020",
+                        "20160525 13:30:00.025",
+                        "20160525 13:30:00.035",
+                        "20160525 13:30:00.040",
+                        "20160525 13:30:00.055",
+                        "20160525 13:30:00.060",
+                        "20160525 13:30:00.065",
+                    ]
+                ),
+                "key": [2, 1, 1, 3, 2, 1, 2, 3],
+                "value2": [2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8],
+            },
+            columns=["time", "key", "value2"],
+        )
+
+        result = merge_asof(df1, df2, on="time", by="key")
+
+        expected = pd.DataFrame(
+            {
+                "time": to_datetime(
+                    [
+                        "20160525 13:30:00.020",
+                        "20160525 13:30:00.030",
+                        "20160525 13:30:00.040",
+                        "20160525 13:30:00.050",
+                        "20160525 13:30:00.060",
+                    ]
+                ),
+                "key": [1, 2, 1, 3, 2],
+                "value1": [1.1, 1.2, 1.3, 1.4, 1.5],
+                "value2": [2.2, 2.1, 2.3, 2.4, 2.7],
+            },
+            columns=["time", "key", "value1", "value2"],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_on_float(self):
+        # mimics how to determine the minimum-price variation
+        df1 = pd.DataFrame(
+            {
+                "price": [5.01, 0.0023, 25.13, 340.05, 30.78, 1040.90, 0.0078],
+                "symbol": list("ABCDEFG"),
+            },
+            columns=["symbol", "price"],
+        )
+
+        df2 = pd.DataFrame(
+            {"price": [0.0, 1.0, 100.0], "mpv": [0.0001, 0.01, 0.05]},
+            columns=["price", "mpv"],
+        )
+
+        df1 = df1.sort_values("price").reset_index(drop=True)
+
+        result = merge_asof(df1, df2, on="price")
+
+        expected = pd.DataFrame(
+            {
+                "symbol": list("BGACEDF"),
+                "price": [0.0023, 0.0078, 5.01, 25.13, 30.78, 340.05, 1040.90],
+                "mpv": [0.0001, 0.0001, 0.01, 0.01, 0.01, 0.05, 0.05],
+            },
+            columns=["symbol", "price", "mpv"],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_on_specialized_type(self, any_real_numpy_dtype):
+        # see gh-13936
+        dtype = np.dtype(any_real_numpy_dtype).type
+
+        df1 = pd.DataFrame(
+            {"value": [5, 2, 25, 100, 78, 120, 79], "symbol": list("ABCDEFG")},
+            columns=["symbol", "value"],
+        )
+        df1.value = dtype(df1.value)
+
+        df2 = pd.DataFrame(
+            {"value": [0, 80, 120, 125], "result": list("xyzw")},
+            columns=["value", "result"],
+        )
+        df2.value = dtype(df2.value)
+
+        df1 = df1.sort_values("value").reset_index(drop=True)
+        result = merge_asof(df1, df2, on="value")
+
+        expected = pd.DataFrame(
+            {
+                "symbol": list("BACEGDF"),
+                "value": [2, 5, 25, 78, 79, 100, 120],
+                "result": list("xxxxxyz"),
+            },
+            columns=["symbol", "value", "result"],
+        )
+        expected.value = dtype(expected.value)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_on_specialized_type_by_int(self, any_real_numpy_dtype):
+        # see gh-13936
+        dtype = np.dtype(any_real_numpy_dtype).type
+
+        df1 = pd.DataFrame(
+            {
+                "value": [5, 2, 25, 100, 78, 120, 79],
+                "key": [1, 2, 3, 2, 3, 1, 2],
+                "symbol": list("ABCDEFG"),
+            },
+            columns=["symbol", "key", "value"],
+        )
+        df1.value = dtype(df1.value)
+
+        df2 = pd.DataFrame(
+            {"value": [0, 80, 120, 125], "key": [1, 2, 2, 3], "result": list("xyzw")},
+            columns=["value", "key", "result"],
+        )
+        df2.value = dtype(df2.value)
+
+        df1 = df1.sort_values("value").reset_index(drop=True)
+        result = merge_asof(df1, df2, on="value", by="key")
+
+        expected = pd.DataFrame(
+            {
+                "symbol": list("BACEGDF"),
+                "key": [2, 1, 3, 3, 2, 2, 1],
+                "value": [2, 5, 25, 78, 79, 100, 120],
+                "result": [np.nan, "x", np.nan, np.nan, np.nan, "y", "x"],
+            },
+            columns=["symbol", "key", "value", "result"],
+        )
+        expected.value = dtype(expected.value)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_on_float_by_int(self):
+        # type specialize both "by" and "on" parameters
+        df1 = pd.DataFrame(
+            {
+                "symbol": list("AAABBBCCC"),
+                "exch": [1, 2, 3, 1, 2, 3, 1, 2, 3],
+                "price": [
+                    3.26,
+                    3.2599,
+                    3.2598,
+                    12.58,
+                    12.59,
+                    12.5,
+                    378.15,
+                    378.2,
+                    378.25,
+                ],
+            },
+            columns=["symbol", "exch", "price"],
+        )
+
+        df2 = pd.DataFrame(
+            {
+                "exch": [1, 1, 1, 2, 2, 2, 3, 3, 3],
+                "price": [0.0, 1.0, 100.0, 0.0, 5.0, 100.0, 0.0, 5.0, 1000.0],
+                "mpv": [0.0001, 0.01, 0.05, 0.0001, 0.01, 0.1, 0.0001, 0.25, 1.0],
+            },
+            columns=["exch", "price", "mpv"],
+        )
+
+        df1 = df1.sort_values("price").reset_index(drop=True)
+        df2 = df2.sort_values("price").reset_index(drop=True)
+
+        result = merge_asof(df1, df2, on="price", by="exch")
+
+        expected = pd.DataFrame(
+            {
+                "symbol": list("AAABBBCCC"),
+                "exch": [3, 2, 1, 3, 1, 2, 1, 2, 3],
+                "price": [
+                    3.2598,
+                    3.2599,
+                    3.26,
+                    12.5,
+                    12.58,
+                    12.59,
+                    378.15,
+                    378.2,
+                    378.25,
+                ],
+                "mpv": [0.0001, 0.0001, 0.01, 0.25, 0.01, 0.01, 0.05, 0.1, 0.25],
+            },
+            columns=["symbol", "exch", "price", "mpv"],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_datatype_error_raises(self):
+        msg = r"Incompatible merge dtype, .*, both sides must have numeric dtype"
+
+        left = pd.DataFrame({"left_val": [1, 5, 10], "a": ["a", "b", "c"]})
+        right = pd.DataFrame({"right_val": [1, 2, 3, 6, 7], "a": [1, 2, 3, 6, 7]})
+
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(left, right, on="a")
+
+    def test_merge_datatype_categorical_error_raises(self):
+        msg = (
+            r"incompatible merge keys \[0\] .* both sides category, "
+            "but not equal ones"
+        )
+
+        left = pd.DataFrame(
+            {"left_val": [1, 5, 10], "a": pd.Categorical(["a", "b", "c"])}
+        )
+        right = pd.DataFrame(
+            {
+                "right_val": [1, 2, 3, 6, 7],
+                "a": pd.Categorical(["a", "X", "c", "X", "b"]),
+            }
+        )
+
+        with pytest.raises(MergeError, match=msg):
+            merge_asof(left, right, on="a")
+
+    def test_merge_groupby_multiple_column_with_categorical_column(self):
+        # GH 16454
+        df = pd.DataFrame({"x": [0], "y": [0], "z": pd.Categorical([0])})
+        result = merge_asof(df, df, on="x", by=["y", "z"])
+        expected = pd.DataFrame({"x": [0], "y": [0], "z": pd.Categorical([0])})
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "func", [lambda x: x, lambda x: to_datetime(x)], ids=["numeric", "datetime"]
+    )
+    @pytest.mark.parametrize("side", ["left", "right"])
+    def test_merge_on_nans(self, func, side):
+        # GH 23189
+        msg = f"Merge keys contain null values on {side} side"
+        nulls = func([1.0, 5.0, np.nan])
+        non_nulls = func([1.0, 5.0, 10.0])
+        df_null = pd.DataFrame({"a": nulls, "left_val": ["a", "b", "c"]})
+        df = pd.DataFrame({"a": non_nulls, "right_val": [1, 6, 11]})
+
+        with pytest.raises(ValueError, match=msg):
+            if side == "left":
+                merge_asof(df_null, df, on="a")
+            else:
+                merge_asof(df, df_null, on="a")
+
+    def test_by_nullable(self, any_numeric_ea_dtype):
+        # Note: this test passes if instead of using pd.array we use
+        #  np.array([np.nan, 1]).  Other than that, I (@jbrockmendel)
+        #  have NO IDEA what the expected behavior is.
+        # TODO(GH#32306): may be relevant to the expected behavior here.
+
+        arr = pd.array([pd.NA, 0, 1], dtype=any_numeric_ea_dtype)
+        if arr.dtype.kind in ["i", "u"]:
+            max_val = np.iinfo(arr.dtype.numpy_dtype).max
+        else:
+            max_val = np.finfo(arr.dtype.numpy_dtype).max
+        # set value s.t. (at least for integer dtypes) arr._values_for_argsort
+        #  is not an injection
+        arr[2] = max_val
+
+        left = pd.DataFrame(
+            {
+                "by_col1": arr,
+                "by_col2": ["HELLO", "To", "You"],
+                "on_col": [2, 4, 6],
+                "value": ["a", "c", "e"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "by_col1": arr,
+                "by_col2": ["WORLD", "Wide", "Web"],
+                "on_col": [1, 2, 6],
+                "value": ["b", "d", "f"],
+            }
+        )
+
+        result = merge_asof(left, right, by=["by_col1", "by_col2"], on="on_col")
+        expected = pd.DataFrame(
+            {
+                "by_col1": arr,
+                "by_col2": ["HELLO", "To", "You"],
+                "on_col": [2, 4, 6],
+                "value_x": ["a", "c", "e"],
+            }
+        )
+        expected["value_y"] = np.array([np.nan, np.nan, np.nan], dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_by_col_tz_aware(self):
+        # GH 21184
+        left = pd.DataFrame(
+            {
+                "by_col": pd.DatetimeIndex(["2018-01-01"]).tz_localize("UTC"),
+                "on_col": [2],
+                "values": ["a"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "by_col": pd.DatetimeIndex(["2018-01-01"]).tz_localize("UTC"),
+                "on_col": [1],
+                "values": ["b"],
+            }
+        )
+        result = merge_asof(left, right, by="by_col", on="on_col")
+        expected = pd.DataFrame(
+            [[pd.Timestamp("2018-01-01", tz="UTC"), 2, "a", "b"]],
+            columns=["by_col", "on_col", "values_x", "values_y"],
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_by_mixed_tz_aware(self):
+        # GH 26649
+        left = pd.DataFrame(
+            {
+                "by_col1": pd.DatetimeIndex(["2018-01-01"]).tz_localize("UTC"),
+                "by_col2": ["HELLO"],
+                "on_col": [2],
+                "value": ["a"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "by_col1": pd.DatetimeIndex(["2018-01-01"]).tz_localize("UTC"),
+                "by_col2": ["WORLD"],
+                "on_col": [1],
+                "value": ["b"],
+            }
+        )
+        result = merge_asof(left, right, by=["by_col1", "by_col2"], on="on_col")
+        expected = pd.DataFrame(
+            [[pd.Timestamp("2018-01-01", tz="UTC"), "HELLO", 2, "a"]],
+            columns=["by_col1", "by_col2", "on_col", "value_x"],
+        )
+        expected["value_y"] = np.array([np.nan], dtype=object)
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["m8[ns]", "M8[us]"])
+    def test_by_datelike(self, dtype):
+        # GH 55453
+        left = pd.DataFrame(
+            {
+                "by_col": np.array([1], dtype=dtype),
+                "on_col": [2],
+                "value": ["a"],
+            }
+        )
+        right = pd.DataFrame(
+            {
+                "by_col": np.array([1], dtype=dtype),
+                "on_col": [1],
+                "value": ["b"],
+            }
+        )
+        result = merge_asof(left, right, by="by_col", on="on_col")
+        expected = pd.DataFrame(
+            {
+                "by_col": np.array([1], dtype=dtype),
+                "on_col": [2],
+                "value_x": ["a"],
+                "value_y": ["b"],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_timedelta_tolerance_nearest(self, unit):
+        # GH 27642
+        if unit == "s":
+            pytest.skip(
+                "This test is invalid with unit='s' because that would "
+                "round left['time']"
+            )
+
+        left = pd.DataFrame(
+            list(zip([0, 5, 10, 15, 20, 25], [0, 1, 2, 3, 4, 5])),
+            columns=["time", "left"],
+        )
+
+        left["time"] = pd.to_timedelta(left["time"], "ms").astype(f"m8[{unit}]")
+
+        right = pd.DataFrame(
+            list(zip([0, 3, 9, 12, 15, 18], [0, 1, 2, 3, 4, 5])),
+            columns=["time", "right"],
+        )
+
+        right["time"] = pd.to_timedelta(right["time"], "ms").astype(f"m8[{unit}]")
+
+        expected = pd.DataFrame(
+            list(
+                zip(
+                    [0, 5, 10, 15, 20, 25],
+                    [0, 1, 2, 3, 4, 5],
+                    [0, np.nan, 2, 4, np.nan, np.nan],
+                )
+            ),
+            columns=["time", "left", "right"],
+        )
+
+        expected["time"] = pd.to_timedelta(expected["time"], "ms").astype(f"m8[{unit}]")
+
+        result = merge_asof(
+            left, right, on="time", tolerance=Timedelta("1ms"), direction="nearest"
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_int_type_tolerance(self, any_int_dtype):
+        # GH #28870
+
+        left = pd.DataFrame({"a": [0, 10, 20], "left_val": [1, 2, 3]})
+        right = pd.DataFrame({"a": [5, 15, 25], "right_val": [1, 2, 3]})
+        left["a"] = left["a"].astype(any_int_dtype)
+        right["a"] = right["a"].astype(any_int_dtype)
+
+        expected = pd.DataFrame(
+            {"a": [0, 10, 20], "left_val": [1, 2, 3], "right_val": [np.nan, 1.0, 2.0]}
+        )
+        expected["a"] = expected["a"].astype(any_int_dtype)
+
+        result = merge_asof(left, right, on="a", tolerance=10)
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_index_column_tz(self):
+        # GH 29864
+        index = pd.date_range("2019-10-01", freq="30min", periods=5, tz="UTC")
+        left = pd.DataFrame([0.9, 0.8, 0.7, 0.6], columns=["xyz"], index=index[1:])
+        right = pd.DataFrame({"from_date": index, "abc": [2.46] * 4 + [2.19]})
+        result = merge_asof(
+            left=left, right=right, left_index=True, right_on=["from_date"]
+        )
+        expected = pd.DataFrame(
+            {
+                "xyz": [0.9, 0.8, 0.7, 0.6],
+                "from_date": index[1:],
+                "abc": [2.46] * 3 + [2.19],
+            },
+            index=pd.date_range(
+                "2019-10-01 00:30:00", freq="30min", periods=4, tz="UTC"
+            ),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = merge_asof(
+            left=right, right=left, right_index=True, left_on=["from_date"]
+        )
+        expected = pd.DataFrame(
+            {
+                "from_date": index,
+                "abc": [2.46] * 4 + [2.19],
+                "xyz": [np.nan, 0.9, 0.8, 0.7, 0.6],
+            },
+            index=Index([0, 1, 2, 3, 4]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_left_index_right_index_tolerance(self, unit):
+        # https://github.com/pandas-dev/pandas/issues/35558
+        if unit == "s":
+            pytest.skip(
+                "This test is invalid with unit='s' because that would round dr1"
+            )
+
+        dr1 = pd.date_range(
+            start="1/1/2020", end="1/20/2020", freq="2D", unit=unit
+        ) + Timedelta(seconds=0.4).as_unit(unit)
+        dr2 = pd.date_range(start="1/1/2020", end="2/1/2020", unit=unit)
+
+        df1 = pd.DataFrame({"val1": "foo"}, index=pd.DatetimeIndex(dr1))
+        df2 = pd.DataFrame({"val2": "bar"}, index=pd.DatetimeIndex(dr2))
+
+        expected = pd.DataFrame(
+            {"val1": "foo", "val2": "bar"}, index=pd.DatetimeIndex(dr1)
+        )
+        result = merge_asof(
+            df1,
+            df2,
+            left_index=True,
+            right_index=True,
+            tolerance=Timedelta(seconds=0.5),
+        )
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "kwargs", [{"on": "x"}, {"left_index": True, "right_index": True}]
+)
+@pytest.mark.parametrize(
+    "data",
+    [["2019-06-01 00:09:12", "2019-06-01 00:10:29"], [1.0, "2019-06-01 00:10:29"]],
+)
+def test_merge_asof_non_numerical_dtype(kwargs, data):
+    # GH#29130
+    left = pd.DataFrame({"x": data}, index=data)
+    right = pd.DataFrame({"x": data}, index=data)
+    with pytest.raises(
+        MergeError,
+        match=r"Incompatible merge dtype, .*, both sides must have numeric dtype",
+    ):
+        merge_asof(left, right, **kwargs)
+
+
+def test_merge_asof_non_numerical_dtype_object():
+    # GH#29130
+    left = pd.DataFrame({"a": ["12", "13", "15"], "left_val1": ["a", "b", "c"]})
+    right = pd.DataFrame({"a": ["a", "b", "c"], "left_val": ["d", "e", "f"]})
+    with pytest.raises(
+        MergeError,
+        match=r"Incompatible merge dtype, .*, both sides must have numeric dtype",
+    ):
+        merge_asof(
+            left,
+            right,
+            left_on="left_val1",
+            right_on="a",
+            left_by="a",
+            right_by="left_val",
+        )
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"right_index": True, "left_index": True},
+        {"left_on": "left_time", "right_index": True},
+        {"left_index": True, "right_on": "right"},
+    ],
+)
+def test_merge_asof_index_behavior(kwargs):
+    # GH 33463
+    index = Index([1, 5, 10], name="test")
+    left = pd.DataFrame({"left": ["a", "b", "c"], "left_time": [1, 4, 10]}, index=index)
+    right = pd.DataFrame({"right": [1, 2, 3, 6, 7]}, index=[1, 2, 3, 6, 7])
+    result = merge_asof(left, right, **kwargs)
+
+    expected = pd.DataFrame(
+        {"left": ["a", "b", "c"], "left_time": [1, 4, 10], "right": [1, 3, 7]},
+        index=index,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_asof_numeric_column_in_index():
+    # GH#34488
+    left = pd.DataFrame({"b": [10, 11, 12]}, index=Index([1, 2, 3], name="a"))
+    right = pd.DataFrame({"c": [20, 21, 22]}, index=Index([0, 2, 3], name="a"))
+
+    result = merge_asof(left, right, left_on="a", right_on="a")
+    expected = pd.DataFrame({"a": [1, 2, 3], "b": [10, 11, 12], "c": [20, 21, 22]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_asof_numeric_column_in_multiindex():
+    # GH#34488
+    left = pd.DataFrame(
+        {"b": [10, 11, 12]},
+        index=pd.MultiIndex.from_arrays([[1, 2, 3], ["a", "b", "c"]], names=["a", "z"]),
+    )
+    right = pd.DataFrame(
+        {"c": [20, 21, 22]},
+        index=pd.MultiIndex.from_arrays([[1, 2, 3], ["x", "y", "z"]], names=["a", "y"]),
+    )
+
+    result = merge_asof(left, right, left_on="a", right_on="a")
+    expected = pd.DataFrame({"a": [1, 2, 3], "b": [10, 11, 12], "c": [20, 21, 22]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_asof_numeri_column_in_index_object_dtype():
+    # GH#34488
+    left = pd.DataFrame({"b": [10, 11, 12]}, index=Index(["1", "2", "3"], name="a"))
+    right = pd.DataFrame({"c": [20, 21, 22]}, index=Index(["m", "n", "o"], name="a"))
+
+    with pytest.raises(
+        MergeError,
+        match=r"Incompatible merge dtype, .*, both sides must have numeric dtype",
+    ):
+        merge_asof(left, right, left_on="a", right_on="a")
+
+    left = left.reset_index().set_index(["a", "b"])
+    right = right.reset_index().set_index(["a", "c"])
+
+    with pytest.raises(
+        MergeError,
+        match=r"Incompatible merge dtype, .*, both sides must have numeric dtype",
+    ):
+        merge_asof(left, right, left_on="a", right_on="a")
+
+
+def test_merge_asof_array_as_on():
+    # GH#42844
+    right = pd.DataFrame(
+        {
+            "a": [2, 6],
+            "ts": [pd.Timestamp("2021/01/01 00:37"), pd.Timestamp("2021/01/01 01:40")],
+        }
+    )
+    ts_merge = pd.date_range(
+        start=pd.Timestamp("2021/01/01 00:00"), periods=3, freq="1h"
+    )
+    left = pd.DataFrame({"b": [4, 8, 7]})
+    result = merge_asof(
+        left,
+        right,
+        left_on=ts_merge,
+        right_on="ts",
+        allow_exact_matches=False,
+        direction="backward",
+    )
+    expected = pd.DataFrame({"b": [4, 8, 7], "a": [np.nan, 2, 6], "ts": ts_merge})
+    tm.assert_frame_equal(result, expected)
+
+    result = merge_asof(
+        right,
+        left,
+        left_on="ts",
+        right_on=ts_merge,
+        allow_exact_matches=False,
+        direction="backward",
+    )
+    expected = pd.DataFrame(
+        {
+            "a": [2, 6],
+            "ts": [pd.Timestamp("2021/01/01 00:37"), pd.Timestamp("2021/01/01 01:40")],
+            "b": [4, 8],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_asof_raise_for_duplicate_columns():
+    # GH#50102
+    left = pd.DataFrame([[1, 2, "a"]], columns=["a", "a", "left_val"])
+    right = pd.DataFrame([[1, 1, 1]], columns=["a", "a", "right_val"])
+
+    with pytest.raises(ValueError, match="column label 'a'"):
+        merge_asof(left, right, on="a")
+
+    with pytest.raises(ValueError, match="column label 'a'"):
+        merge_asof(left, right, left_on="a", right_on="right_val")
+
+    with pytest.raises(ValueError, match="column label 'a'"):
+        merge_asof(left, right, left_on="left_val", right_on="a")
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        "Int64",
+        pytest.param("int64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+        pytest.param("timestamp[s][pyarrow]", marks=td.skip_if_no("pyarrow")),
+    ],
+)
+def test_merge_asof_extension_dtype(dtype):
+    # GH 52904
+    left = pd.DataFrame(
+        {
+            "join_col": [1, 3, 5],
+            "left_val": [1, 2, 3],
+        }
+    )
+    right = pd.DataFrame(
+        {
+            "join_col": [2, 3, 4],
+            "right_val": [1, 2, 3],
+        }
+    )
+    left = left.astype({"join_col": dtype})
+    right = right.astype({"join_col": dtype})
+    result = merge_asof(left, right, on="join_col")
+    expected = pd.DataFrame(
+        {
+            "join_col": [1, 3, 5],
+            "left_val": [1, 2, 3],
+            "right_val": [np.nan, 2.0, 3.0],
+        }
+    )
+    expected = expected.astype({"join_col": dtype})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_asof_read_only_ndarray():
+    # GH 53513
+    left = pd.Series([2], index=[2], name="left")
+    right = pd.Series([1], index=[1], name="right")
+    # set to read-only
+    left.index.values.flags.writeable = False
+    right.index.values.flags.writeable = False
+    result = merge_asof(left, right, left_index=True, right_index=True)
+    expected = pd.DataFrame({"left": [2], "right": [1]}, index=[2])
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_cross.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_cross.py
new file mode 100644
index 0000000000000000000000000000000000000000..14f9036e43fce13580916dacfd6409e4639d025e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_cross.py
@@ -0,0 +1,111 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.reshape.merge import (
+    MergeError,
+    merge,
+)
+
+
+@pytest.mark.parametrize(
+    ("input_col", "output_cols"), [("b", ["a", "b"]), ("a", ["a_x", "a_y"])]
+)
+def test_merge_cross(input_col, output_cols):
+    # GH#5401
+    left = DataFrame({"a": [1, 3]})
+    right = DataFrame({input_col: [3, 4]})
+    left_copy = left.copy()
+    right_copy = right.copy()
+    result = merge(left, right, how="cross")
+    expected = DataFrame({output_cols[0]: [1, 1, 3, 3], output_cols[1]: [3, 4, 3, 4]})
+    tm.assert_frame_equal(result, expected)
+    tm.assert_frame_equal(left, left_copy)
+    tm.assert_frame_equal(right, right_copy)
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"left_index": True},
+        {"right_index": True},
+        {"on": "a"},
+        {"left_on": "a"},
+        {"right_on": "b"},
+    ],
+)
+def test_merge_cross_error_reporting(kwargs):
+    # GH#5401
+    left = DataFrame({"a": [1, 3]})
+    right = DataFrame({"b": [3, 4]})
+    msg = (
+        "Can not pass on, right_on, left_on or set right_index=True or "
+        "left_index=True"
+    )
+    with pytest.raises(MergeError, match=msg):
+        merge(left, right, how="cross", **kwargs)
+
+
+def test_merge_cross_mixed_dtypes():
+    # GH#5401
+    left = DataFrame(["a", "b", "c"], columns=["A"])
+    right = DataFrame(range(2), columns=["B"])
+    result = merge(left, right, how="cross")
+    expected = DataFrame({"A": ["a", "a", "b", "b", "c", "c"], "B": [0, 1, 0, 1, 0, 1]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_cross_more_than_one_column():
+    # GH#5401
+    left = DataFrame({"A": list("ab"), "B": [2, 1]})
+    right = DataFrame({"C": range(2), "D": range(4, 6)})
+    result = merge(left, right, how="cross")
+    expected = DataFrame(
+        {
+            "A": ["a", "a", "b", "b"],
+            "B": [2, 2, 1, 1],
+            "C": [0, 1, 0, 1],
+            "D": [4, 5, 4, 5],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_merge_cross_null_values(nulls_fixture):
+    # GH#5401
+    left = DataFrame({"a": [1, nulls_fixture]})
+    right = DataFrame({"b": ["a", "b"], "c": [1.0, 2.0]})
+    result = merge(left, right, how="cross")
+    expected = DataFrame(
+        {
+            "a": [1, 1, nulls_fixture, nulls_fixture],
+            "b": ["a", "b", "a", "b"],
+            "c": [1.0, 2.0, 1.0, 2.0],
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_join_cross_error_reporting():
+    # GH#5401
+    left = DataFrame({"a": [1, 3]})
+    right = DataFrame({"a": [3, 4]})
+    msg = (
+        "Can not pass on, right_on, left_on or set right_index=True or "
+        "left_index=True"
+    )
+    with pytest.raises(MergeError, match=msg):
+        left.join(right, how="cross", on="a")
+
+
+def test_merge_cross_series():
+    # GH#54055
+    ls = Series([1, 2, 3, 4], index=[1, 2, 3, 4], name="left")
+    rs = Series([3, 4, 5, 6], index=[3, 4, 5, 6], name="right")
+    res = merge(ls, rs, how="cross")
+
+    expected = merge(ls.to_frame(), rs.to_frame(), how="cross")
+    tm.assert_frame_equal(res, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_index_as_string.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_index_as_string.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4271d4face4fb4e90477196cec7919845f37813
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_index_as_string.py
@@ -0,0 +1,186 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+@pytest.fixture
+def df1():
+    return DataFrame(
+        {
+            "outer": [1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4],
+            "inner": [1, 2, 3, 1, 2, 3, 4, 1, 2, 1, 2],
+            "v1": np.linspace(0, 1, 11),
+        }
+    )
+
+
+@pytest.fixture
+def df2():
+    return DataFrame(
+        {
+            "outer": [1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3],
+            "inner": [1, 2, 2, 3, 3, 4, 2, 3, 1, 1, 2, 3],
+            "v2": np.linspace(10, 11, 12),
+        }
+    )
+
+
+@pytest.fixture(params=[[], ["outer"], ["outer", "inner"]])
+def left_df(request, df1):
+    """Construct left test DataFrame with specified levels
+    (any of 'outer', 'inner', and 'v1')
+    """
+    levels = request.param
+    if levels:
+        df1 = df1.set_index(levels)
+
+    return df1
+
+
+@pytest.fixture(params=[[], ["outer"], ["outer", "inner"]])
+def right_df(request, df2):
+    """Construct right test DataFrame with specified levels
+    (any of 'outer', 'inner', and 'v2')
+    """
+    levels = request.param
+
+    if levels:
+        df2 = df2.set_index(levels)
+
+    return df2
+
+
+def compute_expected(df_left, df_right, on=None, left_on=None, right_on=None, how=None):
+    """
+    Compute the expected merge result for the test case.
+
+    This method computes the expected result of merging two DataFrames on
+    a combination of their columns and index levels. It does so by
+    explicitly dropping/resetting their named index levels, performing a
+    merge on their columns, and then finally restoring the appropriate
+    index in the result.
+
+    Parameters
+    ----------
+    df_left : DataFrame
+        The left DataFrame (may have zero or more named index levels)
+    df_right : DataFrame
+        The right DataFrame (may have zero or more named index levels)
+    on : list of str
+        The on parameter to the merge operation
+    left_on : list of str
+        The left_on parameter to the merge operation
+    right_on : list of str
+        The right_on parameter to the merge operation
+    how : str
+        The how parameter to the merge operation
+
+    Returns
+    -------
+    DataFrame
+        The expected merge result
+    """
+    # Handle on param if specified
+    if on is not None:
+        left_on, right_on = on, on
+
+    # Compute input named index levels
+    left_levels = [n for n in df_left.index.names if n is not None]
+    right_levels = [n for n in df_right.index.names if n is not None]
+
+    # Compute output named index levels
+    output_levels = [i for i in left_on if i in right_levels and i in left_levels]
+
+    # Drop index levels that aren't involved in the merge
+    drop_left = [n for n in left_levels if n not in left_on]
+    if drop_left:
+        df_left = df_left.reset_index(drop_left, drop=True)
+
+    drop_right = [n for n in right_levels if n not in right_on]
+    if drop_right:
+        df_right = df_right.reset_index(drop_right, drop=True)
+
+    # Convert remaining index levels to columns
+    reset_left = [n for n in left_levels if n in left_on]
+    if reset_left:
+        df_left = df_left.reset_index(level=reset_left)
+
+    reset_right = [n for n in right_levels if n in right_on]
+    if reset_right:
+        df_right = df_right.reset_index(level=reset_right)
+
+    # Perform merge
+    expected = df_left.merge(df_right, left_on=left_on, right_on=right_on, how=how)
+
+    # Restore index levels
+    if output_levels:
+        expected = expected.set_index(output_levels)
+
+    return expected
+
+
+@pytest.mark.parametrize(
+    "on,how",
+    [
+        (["outer"], "inner"),
+        (["inner"], "left"),
+        (["outer", "inner"], "right"),
+        (["inner", "outer"], "outer"),
+    ],
+)
+def test_merge_indexes_and_columns_on(left_df, right_df, on, how):
+    # Construct expected result
+    expected = compute_expected(left_df, right_df, on=on, how=how)
+
+    # Perform merge
+    result = left_df.merge(right_df, on=on, how=how)
+    tm.assert_frame_equal(result, expected, check_like=True)
+
+
+@pytest.mark.parametrize(
+    "left_on,right_on,how",
+    [
+        (["outer"], ["outer"], "inner"),
+        (["inner"], ["inner"], "right"),
+        (["outer", "inner"], ["outer", "inner"], "left"),
+        (["inner", "outer"], ["inner", "outer"], "outer"),
+    ],
+)
+def test_merge_indexes_and_columns_lefton_righton(
+    left_df, right_df, left_on, right_on, how
+):
+    # Construct expected result
+    expected = compute_expected(
+        left_df, right_df, left_on=left_on, right_on=right_on, how=how
+    )
+
+    # Perform merge
+    result = left_df.merge(right_df, left_on=left_on, right_on=right_on, how=how)
+    tm.assert_frame_equal(result, expected, check_like=True)
+
+
+@pytest.mark.parametrize("left_index", ["inner", ["inner", "outer"]])
+def test_join_indexes_and_columns_on(df1, df2, left_index, join_type):
+    # Construct left_df
+    left_df = df1.set_index(left_index)
+
+    # Construct right_df
+    right_df = df2.set_index(["outer", "inner"])
+
+    # Result
+    expected = (
+        left_df.reset_index()
+        .join(
+            right_df, on=["outer", "inner"], how=join_type, lsuffix="_x", rsuffix="_y"
+        )
+        .set_index(left_index)
+    )
+
+    # Perform join
+    result = left_df.join(
+        right_df, on=["outer", "inner"], how=join_type, lsuffix="_x", rsuffix="_y"
+    )
+
+    tm.assert_frame_equal(result, expected, check_like=True)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_ordered.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_ordered.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfb4e92fb45cd68c8c4bcb7e92fc09ae5e3530a4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_merge_ordered.py
@@ -0,0 +1,211 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    merge_ordered,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def left():
+    return DataFrame({"key": ["a", "c", "e"], "lvalue": [1, 2.0, 3]})
+
+
+@pytest.fixture
+def right():
+    return DataFrame({"key": ["b", "c", "d", "f"], "rvalue": [1, 2, 3.0, 4]})
+
+
+class TestMergeOrdered:
+    def test_basic(self, left, right):
+        result = merge_ordered(left, right, on="key")
+        expected = DataFrame(
+            {
+                "key": ["a", "b", "c", "d", "e", "f"],
+                "lvalue": [1, np.nan, 2, np.nan, 3, np.nan],
+                "rvalue": [np.nan, 1, 2, 3, np.nan, 4],
+            }
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_ffill(self, left, right):
+        result = merge_ordered(left, right, on="key", fill_method="ffill")
+        expected = DataFrame(
+            {
+                "key": ["a", "b", "c", "d", "e", "f"],
+                "lvalue": [1.0, 1, 2, 2, 3, 3.0],
+                "rvalue": [np.nan, 1, 2, 3, 3, 4],
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_multigroup(self, left, right):
+        left = pd.concat([left, left], ignore_index=True)
+
+        left["group"] = ["a"] * 3 + ["b"] * 3
+
+        result = merge_ordered(
+            left, right, on="key", left_by="group", fill_method="ffill"
+        )
+        expected = DataFrame(
+            {
+                "key": ["a", "b", "c", "d", "e", "f"] * 2,
+                "lvalue": [1.0, 1, 2, 2, 3, 3.0] * 2,
+                "rvalue": [np.nan, 1, 2, 3, 3, 4] * 2,
+            }
+        )
+        expected["group"] = ["a"] * 6 + ["b"] * 6
+
+        tm.assert_frame_equal(result, expected.loc[:, result.columns])
+
+        result2 = merge_ordered(
+            right, left, on="key", right_by="group", fill_method="ffill"
+        )
+        tm.assert_frame_equal(result, result2.loc[:, result.columns])
+
+        result = merge_ordered(left, right, on="key", left_by="group")
+        assert result["group"].notna().all()
+
+    @pytest.mark.filterwarnings(
+        "ignore:Passing a BlockManager|Passing a SingleBlockManager:DeprecationWarning"
+    )
+    def test_merge_type(self, left, right):
+        class NotADataFrame(DataFrame):
+            @property
+            def _constructor(self):
+                return NotADataFrame
+
+        nad = NotADataFrame(left)
+        result = nad.merge(right, on="key")
+
+        assert isinstance(result, NotADataFrame)
+
+    @pytest.mark.parametrize(
+        "df_seq, pattern",
+        [
+            ((), "[Nn]o objects"),
+            ([], "[Nn]o objects"),
+            ({}, "[Nn]o objects"),
+            ([None], "objects.*None"),
+            ([None, None], "objects.*None"),
+        ],
+    )
+    def test_empty_sequence_concat(self, df_seq, pattern):
+        # GH 9157
+        with pytest.raises(ValueError, match=pattern):
+            pd.concat(df_seq)
+
+    @pytest.mark.parametrize(
+        "arg", [[DataFrame()], [None, DataFrame()], [DataFrame(), None]]
+    )
+    def test_empty_sequence_concat_ok(self, arg):
+        pd.concat(arg)
+
+    def test_doc_example(self):
+        left = DataFrame(
+            {
+                "group": list("aaabbb"),
+                "key": ["a", "c", "e", "a", "c", "e"],
+                "lvalue": [1, 2, 3] * 2,
+            }
+        )
+
+        right = DataFrame({"key": ["b", "c", "d"], "rvalue": [1, 2, 3]})
+
+        result = merge_ordered(left, right, fill_method="ffill", left_by="group")
+
+        expected = DataFrame(
+            {
+                "group": list("aaaaabbbbb"),
+                "key": ["a", "b", "c", "d", "e"] * 2,
+                "lvalue": [1, 1, 2, 2, 3] * 2,
+                "rvalue": [np.nan, 1, 2, 3, 3] * 2,
+            }
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "left, right, on, left_by, right_by, expected",
+        [
+            (
+                DataFrame({"G": ["g", "g"], "H": ["h", "h"], "T": [1, 3]}),
+                DataFrame({"T": [2], "E": [1]}),
+                ["T"],
+                ["G", "H"],
+                None,
+                DataFrame(
+                    {
+                        "G": ["g"] * 3,
+                        "H": ["h"] * 3,
+                        "T": [1, 2, 3],
+                        "E": [np.nan, 1.0, np.nan],
+                    }
+                ),
+            ),
+            (
+                DataFrame({"G": ["g", "g"], "H": ["h", "h"], "T": [1, 3]}),
+                DataFrame({"T": [2], "E": [1]}),
+                "T",
+                ["G", "H"],
+                None,
+                DataFrame(
+                    {
+                        "G": ["g"] * 3,
+                        "H": ["h"] * 3,
+                        "T": [1, 2, 3],
+                        "E": [np.nan, 1.0, np.nan],
+                    }
+                ),
+            ),
+            (
+                DataFrame({"T": [2], "E": [1]}),
+                DataFrame({"G": ["g", "g"], "H": ["h", "h"], "T": [1, 3]}),
+                ["T"],
+                None,
+                ["G", "H"],
+                DataFrame(
+                    {
+                        "T": [1, 2, 3],
+                        "E": [np.nan, 1.0, np.nan],
+                        "G": ["g"] * 3,
+                        "H": ["h"] * 3,
+                    }
+                ),
+            ),
+        ],
+    )
+    def test_list_type_by(self, left, right, on, left_by, right_by, expected):
+        # GH 35269
+        result = merge_ordered(
+            left=left,
+            right=right,
+            on=on,
+            left_by=left_by,
+            right_by=right_by,
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_left_by_length_equals_to_right_shape0(self):
+        # GH 38166
+        left = DataFrame([["g", "h", 1], ["g", "h", 3]], columns=list("GHE"))
+        right = DataFrame([[2, 1]], columns=list("ET"))
+        result = merge_ordered(left, right, on="E", left_by=["G", "H"])
+        expected = DataFrame(
+            {"G": ["g"] * 3, "H": ["h"] * 3, "E": [1, 2, 3], "T": [np.nan, 1.0, np.nan]}
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_elements_not_in_by_but_in_df(self):
+        # GH 38167
+        left = DataFrame([["g", "h", 1], ["g", "h", 3]], columns=list("GHE"))
+        right = DataFrame([[2, 1]], columns=list("ET"))
+        msg = r"\{'h'\} not found in left columns"
+        with pytest.raises(KeyError, match=msg):
+            merge_ordered(left, right, on="E", left_by=["G", "h"])
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_multi.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_multi.py
new file mode 100644
index 0000000000000000000000000000000000000000..088d1e7e3c85e1009a14c005c60ee5171c07d50a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/reshape/merge/test_multi.py
@@ -0,0 +1,921 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.reshape.concat import concat
+from pandas.core.reshape.merge import merge
+
+
+@pytest.fixture
+def left():
+    """left dataframe (not multi-indexed) for multi-index join tests"""
+    # a little relevant example with NAs
+    key1 = ["bar", "bar", "bar", "foo", "foo", "baz", "baz", "qux", "qux", "snap"]
+    key2 = ["two", "one", "three", "one", "two", "one", "two", "two", "three", "one"]
+
+    data = np.random.default_rng(2).standard_normal(len(key1))
+    return DataFrame({"key1": key1, "key2": key2, "data": data})
+
+
+@pytest.fixture
+def right(multiindex_dataframe_random_data):
+    """right dataframe (multi-indexed) for multi-index join tests"""
+    df = multiindex_dataframe_random_data
+    df.index.names = ["key1", "key2"]
+
+    df.columns = ["j_one", "j_two", "j_three"]
+    return df
+
+
+@pytest.fixture
+def left_multi():
+    return DataFrame(
+        {
+            "Origin": ["A", "A", "B", "B", "C"],
+            "Destination": ["A", "B", "A", "C", "A"],
+            "Period": ["AM", "AM", "IP", "AM", "OP"],
+            "TripPurp": ["hbw", "nhb", "hbo", "nhb", "hbw"],
+            "Trips": [1987, 3647, 2470, 4296, 4444],
+        },
+        columns=["Origin", "Destination", "Period", "TripPurp", "Trips"],
+    ).set_index(["Origin", "Destination", "Period", "TripPurp"])
+
+
+@pytest.fixture
+def right_multi():
+    return DataFrame(
+        {
+            "Origin": ["A", "A", "B", "B", "C", "C", "E"],
+            "Destination": ["A", "B", "A", "B", "A", "B", "F"],
+            "Period": ["AM", "AM", "IP", "AM", "OP", "IP", "AM"],
+            "LinkType": ["a", "b", "c", "b", "a", "b", "a"],
+            "Distance": [100, 80, 90, 80, 75, 35, 55],
+        },
+        columns=["Origin", "Destination", "Period", "LinkType", "Distance"],
+    ).set_index(["Origin", "Destination", "Period", "LinkType"])
+
+
+@pytest.fixture
+def on_cols_multi():
+    return ["Origin", "Destination", "Period"]
+
+
+@pytest.fixture
+def idx_cols_multi():
+    return ["Origin", "Destination", "Period", "TripPurp", "LinkType"]
+
+
+class TestMergeMulti:
+    def test_merge_on_multikey(self, left, right, join_type):
+        on_cols = ["key1", "key2"]
+        result = left.join(right, on=on_cols, how=join_type).reset_index(drop=True)
+
+        expected = merge(left, right.reset_index(), on=on_cols, how=join_type)
+
+        tm.assert_frame_equal(result, expected)
+
+        result = left.join(right, on=on_cols, how=join_type, sort=True).reset_index(
+            drop=True
+        )
+
+        expected = merge(
+            left, right.reset_index(), on=on_cols, how=join_type, sort=True
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("sort", [False, True])
+    def test_left_join_multi_index(self, sort):
+        icols = ["1st", "2nd", "3rd"]
+
+        def bind_cols(df):
+            iord = lambda a: 0 if a != a else ord(a)
+            f = lambda ts: ts.map(iord) - ord("a")
+            return f(df["1st"]) + f(df["3rd"]) * 1e2 + df["2nd"].fillna(0) * 1e4
+
+        def run_asserts(left, right, sort):
+            res = left.join(right, on=icols, how="left", sort=sort)
+
+            assert len(left) < len(res) + 1
+            assert not res["4th"].isna().any()
+            assert not res["5th"].isna().any()
+
+            tm.assert_series_equal(res["4th"], -res["5th"], check_names=False)
+            result = bind_cols(res.iloc[:, :-2])
+            tm.assert_series_equal(res["4th"], result, check_names=False)
+            assert result.name is None
+
+            if sort:
+                tm.assert_frame_equal(res, res.sort_values(icols, kind="mergesort"))
+
+            out = merge(left, right.reset_index(), on=icols, sort=sort, how="left")
+
+            res.index = RangeIndex(len(res))
+            tm.assert_frame_equal(out, res)
+
+        lc = list(map(chr, np.arange(ord("a"), ord("z") + 1)))
+        left = DataFrame(
+            np.random.default_rng(2).choice(lc, (5000, 2)), columns=["1st", "3rd"]
+        )
+        # Explicit cast to float to avoid implicit cast when setting nan
+        left.insert(
+            1,
+            "2nd",
+            np.random.default_rng(2).integers(0, 1000, len(left)).astype("float"),
+        )
+
+        i = np.random.default_rng(2).permutation(len(left))
+        right = left.iloc[i].copy()
+
+        left["4th"] = bind_cols(left)
+        right["5th"] = -bind_cols(right)
+        right.set_index(icols, inplace=True)
+
+        run_asserts(left, right, sort)
+
+        # inject some nulls
+        left.loc[1::23, "1st"] = np.nan
+        left.loc[2::37, "2nd"] = np.nan
+        left.loc[3::43, "3rd"] = np.nan
+        left["4th"] = bind_cols(left)
+
+        i = np.random.default_rng(2).permutation(len(left))
+        right = left.iloc[i, :-1]
+        right["5th"] = -bind_cols(right)
+        right.set_index(icols, inplace=True)
+
+        run_asserts(left, right, sort)
+
+    @pytest.mark.parametrize("sort", [False, True])
+    def test_merge_right_vs_left(self, left, right, sort):
+        # compare left vs right merge with multikey
+        on_cols = ["key1", "key2"]
+        merged_left_right = left.merge(
+            right, left_on=on_cols, right_index=True, how="left", sort=sort
+        )
+
+        merge_right_left = right.merge(
+            left, right_on=on_cols, left_index=True, how="right", sort=sort
+        )
+
+        # Reorder columns
+        merge_right_left = merge_right_left[merged_left_right.columns]
+
+        tm.assert_frame_equal(merged_left_right, merge_right_left)
+
+    def test_merge_multiple_cols_with_mixed_cols_index(self):
+        # GH29522
+        s = Series(
+            range(6),
+            MultiIndex.from_product([["A", "B"], [1, 2, 3]], names=["lev1", "lev2"]),
+            name="Amount",
+        )
+        df = DataFrame({"lev1": list("AAABBB"), "lev2": [1, 2, 3, 1, 2, 3], "col": 0})
+        result = merge(df, s.reset_index(), on=["lev1", "lev2"])
+        expected = DataFrame(
+            {
+                "lev1": list("AAABBB"),
+                "lev2": [1, 2, 3, 1, 2, 3],
+                "col": [0] * 6,
+                "Amount": range(6),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_compress_group_combinations(self):
+        # ~ 40000000 possible unique groups
+        key1 = tm.makeStringIndex(10000)
+        key1 = np.tile(key1, 2)
+        key2 = key1[::-1]
+
+        df = DataFrame(
+            {
+                "key1": key1,
+                "key2": key2,
+                "value1": np.random.default_rng(2).standard_normal(20000),
+            }
+        )
+
+        df2 = DataFrame(
+            {
+                "key1": key1[::2],
+                "key2": key2[::2],
+                "value2": np.random.default_rng(2).standard_normal(10000),
+            }
+        )
+
+        # just to hit the label compression code path
+        merge(df, df2, how="outer")
+
+    def test_left_join_index_preserve_order(self):
+        on_cols = ["k1", "k2"]
+        left = DataFrame(
+            {
+                "k1": [0, 1, 2] * 8,
+                "k2": ["foo", "bar"] * 12,
+                "v": np.array(np.arange(24), dtype=np.int64),
+            }
+        )
+
+        index = MultiIndex.from_tuples([(2, "bar"), (1, "foo")])
+        right = DataFrame({"v2": [5, 7]}, index=index)
+
+        result = left.join(right, on=on_cols)
+
+        expected = left.copy()
+        expected["v2"] = np.nan
+        expected.loc[(expected.k1 == 2) & (expected.k2 == "bar"), "v2"] = 5
+        expected.loc[(expected.k1 == 1) & (expected.k2 == "foo"), "v2"] = 7
+
+        tm.assert_frame_equal(result, expected)
+
+        result.sort_values(on_cols, kind="mergesort", inplace=True)
+        expected = left.join(right, on=on_cols, sort=True)
+
+        tm.assert_frame_equal(result, expected)
+
+        # test join with multi dtypes blocks
+        left = DataFrame(
+            {
+                "k1": [0, 1, 2] * 8,
+                "k2": ["foo", "bar"] * 12,
+                "k3": np.array([0, 1, 2] * 8, dtype=np.float32),
+                "v": np.array(np.arange(24), dtype=np.int32),
+            }
+        )
+
+        index = MultiIndex.from_tuples([(2, "bar"), (1, "foo")])
+        right = DataFrame({"v2": [5, 7]}, index=index)
+
+        result = left.join(right, on=on_cols)
+
+        expected = left.copy()
+        expected["v2"] = np.nan
+        expected.loc[(expected.k1 == 2) & (expected.k2 == "bar"), "v2"] = 5
+        expected.loc[(expected.k1 == 1) & (expected.k2 == "foo"), "v2"] = 7
+
+        tm.assert_frame_equal(result, expected)
+
+        result = result.sort_values(on_cols, kind="mergesort")
+        expected = left.join(right, on=on_cols, sort=True)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_left_join_index_multi_match_multiindex(self):
+        left = DataFrame(
+            [
+                ["X", "Y", "C", "a"],
+                ["W", "Y", "C", "e"],
+                ["V", "Q", "A", "h"],
+                ["V", "R", "D", "i"],
+                ["X", "Y", "D", "b"],
+                ["X", "Y", "A", "c"],
+                ["W", "Q", "B", "f"],
+                ["W", "R", "C", "g"],
+                ["V", "Y", "C", "j"],
+                ["X", "Y", "B", "d"],
+            ],
+            columns=["cola", "colb", "colc", "tag"],
+            index=[3, 2, 0, 1, 7, 6, 4, 5, 9, 8],
+        )
+
+        right = DataFrame(
+            [
+                ["W", "R", "C", 0],
+                ["W", "Q", "B", 3],
+                ["W", "Q", "B", 8],
+                ["X", "Y", "A", 1],
+                ["X", "Y", "A", 4],
+                ["X", "Y", "B", 5],
+                ["X", "Y", "C", 6],
+                ["X", "Y", "C", 9],
+                ["X", "Q", "C", -6],
+                ["X", "R", "C", -9],
+                ["V", "Y", "C", 7],
+                ["V", "R", "D", 2],
+                ["V", "R", "D", -1],
+                ["V", "Q", "A", -3],
+            ],
+            columns=["col1", "col2", "col3", "val"],
+        ).set_index(["col1", "col2", "col3"])
+
+        result = left.join(right, on=["cola", "colb", "colc"], how="left")
+
+        expected = DataFrame(
+            [
+                ["X", "Y", "C", "a", 6],
+                ["X", "Y", "C", "a", 9],
+                ["W", "Y", "C", "e", np.nan],
+                ["V", "Q", "A", "h", -3],
+                ["V", "R", "D", "i", 2],
+                ["V", "R", "D", "i", -1],
+                ["X", "Y", "D", "b", np.nan],
+                ["X", "Y", "A", "c", 1],
+                ["X", "Y", "A", "c", 4],
+                ["W", "Q", "B", "f", 3],
+                ["W", "Q", "B", "f", 8],
+                ["W", "R", "C", "g", 0],
+                ["V", "Y", "C", "j", 7],
+                ["X", "Y", "B", "d", 5],
+            ],
+            columns=["cola", "colb", "colc", "tag", "val"],
+            index=[3, 3, 2, 0, 1, 1, 7, 6, 6, 4, 4, 5, 9, 8],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        result = left.join(right, on=["cola", "colb", "colc"], how="left", sort=True)
+
+        expected = expected.sort_values(["cola", "colb", "colc"], kind="mergesort")
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_left_join_index_multi_match(self):
+        left = DataFrame(
+            [["c", 0], ["b", 1], ["a", 2], ["b", 3]],
+            columns=["tag", "val"],
+            index=[2, 0, 1, 3],
+        )
+
+        right = DataFrame(
+            [
+                ["a", "v"],
+                ["c", "w"],
+                ["c", "x"],
+                ["d", "y"],
+                ["a", "z"],
+                ["c", "r"],
+                ["e", "q"],
+                ["c", "s"],
+            ],
+            columns=["tag", "char"],
+        ).set_index("tag")
+
+        result = left.join(right, on="tag", how="left")
+
+        expected = DataFrame(
+            [
+                ["c", 0, "w"],
+                ["c", 0, "x"],
+                ["c", 0, "r"],
+                ["c", 0, "s"],
+                ["b", 1, np.nan],
+                ["a", 2, "v"],
+                ["a", 2, "z"],
+                ["b", 3, np.nan],
+            ],
+            columns=["tag", "val", "char"],
+            index=[2, 2, 2, 2, 0, 1, 1, 3],
+        )
+
+        tm.assert_frame_equal(result, expected)
+
+        result = left.join(right, on="tag", how="left", sort=True)
+        expected2 = expected.sort_values("tag", kind="mergesort")
+
+        tm.assert_frame_equal(result, expected2)
+
+        # GH7331 - maintain left frame order in left merge
+        result = merge(left, right.reset_index(), how="left", on="tag")
+        expected.index = RangeIndex(len(expected))
+        tm.assert_frame_equal(result, expected)
+
+    def test_left_merge_na_buglet(self):
+        left = DataFrame(
+            {
+                "id": list("abcde"),
+                "v1": np.random.default_rng(2).standard_normal(5),
+                "v2": np.random.default_rng(2).standard_normal(5),
+                "dummy": list("abcde"),
+                "v3": np.random.default_rng(2).standard_normal(5),
+            },
+            columns=["id", "v1", "v2", "dummy", "v3"],
+        )
+        right = DataFrame(
+            {
+                "id": ["a", "b", np.nan, np.nan, np.nan],
+                "sv3": [1.234, 5.678, np.nan, np.nan, np.nan],
+            }
+        )
+
+        result = merge(left, right, on="id", how="left")
+
+        rdf = right.drop(["id"], axis=1)
+        expected = left.join(rdf)
+        tm.assert_frame_equal(result, expected)
+
+    def test_merge_na_keys(self):
+        data = [
+            [1950, "A", 1.5],
+            [1950, "B", 1.5],
+            [1955, "B", 1.5],
+            [1960, "B", np.nan],
+            [1970, "B", 4.0],
+            [1950, "C", 4.0],
+            [1960, "C", np.nan],
+            [1965, "C", 3.0],
+            [1970, "C", 4.0],
+        ]
+
+        frame = DataFrame(data, columns=["year", "panel", "data"])
+
+        other_data = [
+            [1960, "A", np.nan],
+            [1970, "A", np.nan],
+            [1955, "A", np.nan],
+            [1965, "A", np.nan],
+            [1965, "B", np.nan],
+            [1955, "C", np.nan],
+        ]
+        other = DataFrame(other_data, columns=["year", "panel", "data"])
+
+        result = frame.merge(other, how="outer")
+
+        expected = frame.fillna(-999).merge(other.fillna(-999), how="outer")
+        expected = expected.replace(-999, np.nan)
+
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [None, np.asarray, Series, Index])
+    def test_merge_datetime_index(self, klass):
+        # see gh-19038
+        df = DataFrame(
+            [1, 2, 3], ["2016-01-01", "2017-01-01", "2018-01-01"], columns=["a"]
+        )
+        df.index = pd.to_datetime(df.index)
+        on_vector = df.index.year
+
+        if klass is not None:
+            on_vector = klass(on_vector)
+
+        exp_years = np.array([2016, 2017, 2018], dtype=np.int32)
+        expected = DataFrame({"a": [1, 2, 3], "key_1": exp_years})
+
+        result = df.merge(df, on=["a", on_vector], how="inner")
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame({"key_0": exp_years, "a_x": [1, 2, 3], "a_y": [1, 2, 3]})
+
+        result = df.merge(df, on=[df.index.year], how="inner")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("merge_type", ["left", "right"])
+    def test_merge_datetime_multi_index_empty_df(self, merge_type):
+        # see gh-36895
+
+        left = DataFrame(
+            data={
+                "data": [1.5, 1.5],
+            },
+            index=MultiIndex.from_tuples(
+                [[Timestamp("1950-01-01"), "A"], [Timestamp("1950-01-02"), "B"]],
+                names=["date", "panel"],
+            ),
+        )
+
+        right = DataFrame(
+            index=MultiIndex.from_tuples([], names=["date", "panel"]), columns=["state"]
+        )
+
+        expected_index = MultiIndex.from_tuples(
+            [[Timestamp("1950-01-01"), "A"], [Timestamp("1950-01-02"), "B"]],
+            names=["date", "panel"],
+        )
+
+        if merge_type == "left":
+            expected = DataFrame(
+                data={
+                    "data": [1.5, 1.5],
+                    "state": np.array([np.nan, np.nan], dtype=object),
+                },
+                index=expected_index,
+            )
+            results_merge = left.merge(right, how="left", on=["date", "panel"])
+            results_join = left.join(right, how="left")
+        else:
+            expected = DataFrame(
+                data={
+                    "state": np.array([np.nan, np.nan], dtype=object),
+                    "data": [1.5, 1.5],
+                },
+                index=expected_index,
+            )
+            results_merge = right.merge(left, how="right", on=["date", "panel"])
+            results_join = right.join(left, how="right")
+
+        tm.assert_frame_equal(results_merge, expected)
+        tm.assert_frame_equal(results_join, expected)
+
+    @pytest.fixture
+    def household(self):
+        household = DataFrame(
+            {
+                "household_id": [1, 2, 3],
+                "male": [0, 1, 0],
+                "wealth": [196087.3, 316478.7, 294750],
+            },
+            columns=["household_id", "male", "wealth"],
+        ).set_index("household_id")
+        return household
+
+    @pytest.fixture
+    def portfolio(self):
+        portfolio = DataFrame(
+            {
+                "household_id": [1, 2, 2, 3, 3, 3, 4],
+                "asset_id": [
+                    "nl0000301109",
+                    "nl0000289783",
+                    "gb00b03mlx29",
+                    "gb00b03mlx29",
+                    "lu0197800237",
+                    "nl0000289965",
+                    np.nan,
+                ],
+                "name": [
+                    "ABN Amro",
+                    "Robeco",
+                    "Royal Dutch Shell",
+                    "Royal Dutch Shell",
+                    "AAB Eastern Europe Equity Fund",
+                    "Postbank BioTech Fonds",
+                    np.nan,
+                ],
+                "share": [1.0, 0.4, 0.6, 0.15, 0.6, 0.25, 1.0],
+            },
+            columns=["household_id", "asset_id", "name", "share"],
+        ).set_index(["household_id", "asset_id"])
+        return portfolio
+
+    @pytest.fixture
+    def expected(self):
+        expected = (
+            DataFrame(
+                {
+                    "male": [0, 1, 1, 0, 0, 0],
+                    "wealth": [
+                        196087.3,
+                        316478.7,
+                        316478.7,
+                        294750.0,
+                        294750.0,
+                        294750.0,
+                    ],
+                    "name": [
+                        "ABN Amro",
+                        "Robeco",
+                        "Royal Dutch Shell",
+                        "Royal Dutch Shell",
+                        "AAB Eastern Europe Equity Fund",
+                        "Postbank BioTech Fonds",
+                    ],
+                    "share": [1.00, 0.40, 0.60, 0.15, 0.60, 0.25],
+                    "household_id": [1, 2, 2, 3, 3, 3],
+                    "asset_id": [
+                        "nl0000301109",
+                        "nl0000289783",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "lu0197800237",
+                        "nl0000289965",
+                    ],
+                }
+            )
+            .set_index(["household_id", "asset_id"])
+            .reindex(columns=["male", "wealth", "name", "share"])
+        )
+        return expected
+
+    def test_join_multi_levels(self, portfolio, household, expected):
+        portfolio = portfolio.copy()
+        household = household.copy()
+
+        # GH 3662
+        # merge multi-levels
+        result = household.join(portfolio, how="inner")
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_multi_levels_merge_equivalence(self, portfolio, household, expected):
+        portfolio = portfolio.copy()
+        household = household.copy()
+
+        # equivalency
+        result = merge(
+            household.reset_index(),
+            portfolio.reset_index(),
+            on=["household_id"],
+            how="inner",
+        ).set_index(["household_id", "asset_id"])
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_multi_levels_outer(self, portfolio, household, expected):
+        portfolio = portfolio.copy()
+        household = household.copy()
+
+        result = household.join(portfolio, how="outer")
+        expected = concat(
+            [
+                expected,
+                (
+                    DataFrame(
+                        {"share": [1.00]},
+                        index=MultiIndex.from_tuples(
+                            [(4, np.nan)], names=["household_id", "asset_id"]
+                        ),
+                    )
+                ),
+            ],
+            axis=0,
+            sort=True,
+        ).reindex(columns=expected.columns)
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_multi_levels_invalid(self, portfolio, household):
+        portfolio = portfolio.copy()
+        household = household.copy()
+
+        # invalid cases
+        household.index.name = "foo"
+
+        with pytest.raises(
+            ValueError, match="cannot join with no overlapping index names"
+        ):
+            household.join(portfolio, how="inner")
+
+        portfolio2 = portfolio.copy()
+        portfolio2.index.set_names(["household_id", "foo"])
+
+        with pytest.raises(ValueError, match="columns overlap but no suffix specified"):
+            portfolio2.join(portfolio, how="inner")
+
+    def test_join_multi_levels2(self):
+        # some more advanced merges
+        # GH6360
+        household = DataFrame(
+            {
+                "household_id": [1, 2, 2, 3, 3, 3, 4],
+                "asset_id": [
+                    "nl0000301109",
+                    "nl0000301109",
+                    "gb00b03mlx29",
+                    "gb00b03mlx29",
+                    "lu0197800237",
+                    "nl0000289965",
+                    np.nan,
+                ],
+                "share": [1.0, 0.4, 0.6, 0.15, 0.6, 0.25, 1.0],
+            },
+            columns=["household_id", "asset_id", "share"],
+        ).set_index(["household_id", "asset_id"])
+
+        log_return = DataFrame(
+            {
+                "asset_id": [
+                    "gb00b03mlx29",
+                    "gb00b03mlx29",
+                    "gb00b03mlx29",
+                    "lu0197800237",
+                    "lu0197800237",
+                ],
+                "t": [233, 234, 235, 180, 181],
+                "log_return": [
+                    0.09604978,
+                    -0.06524096,
+                    0.03532373,
+                    0.03025441,
+                    0.036997,
+                ],
+            }
+        ).set_index(["asset_id", "t"])
+
+        expected = (
+            DataFrame(
+                {
+                    "household_id": [2, 2, 2, 3, 3, 3, 3, 3],
+                    "asset_id": [
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "lu0197800237",
+                        "lu0197800237",
+                    ],
+                    "t": [233, 234, 235, 233, 234, 235, 180, 181],
+                    "share": [0.6, 0.6, 0.6, 0.15, 0.15, 0.15, 0.6, 0.6],
+                    "log_return": [
+                        0.09604978,
+                        -0.06524096,
+                        0.03532373,
+                        0.09604978,
+                        -0.06524096,
+                        0.03532373,
+                        0.03025441,
+                        0.036997,
+                    ],
+                }
+            )
+            .set_index(["household_id", "asset_id", "t"])
+            .reindex(columns=["share", "log_return"])
+        )
+
+        # this is the equivalency
+        result = merge(
+            household.reset_index(),
+            log_return.reset_index(),
+            on=["asset_id"],
+            how="inner",
+        ).set_index(["household_id", "asset_id", "t"])
+        tm.assert_frame_equal(result, expected)
+
+        expected = (
+            DataFrame(
+                {
+                    "household_id": [1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4],
+                    "asset_id": [
+                        "nl0000301109",
+                        "nl0000301109",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "gb00b03mlx29",
+                        "lu0197800237",
+                        "lu0197800237",
+                        "nl0000289965",
+                        None,
+                    ],
+                    "t": [
+                        None,
+                        None,
+                        233,
+                        234,
+                        235,
+                        233,
+                        234,
+                        235,
+                        180,
+                        181,
+                        None,
+                        None,
+                    ],
+                    "share": [
+                        1.0,
+                        0.4,
+                        0.6,
+                        0.6,
+                        0.6,
+                        0.15,
+                        0.15,
+                        0.15,
+                        0.6,
+                        0.6,
+                        0.25,
+                        1.0,
+                    ],
+                    "log_return": [
+                        None,
+                        None,
+                        0.09604978,
+                        -0.06524096,
+                        0.03532373,
+                        0.09604978,
+                        -0.06524096,
+                        0.03532373,
+                        0.03025441,
+                        0.036997,
+                        None,
+                        None,
+                    ],
+                }
+            )
+            .set_index(["household_id", "asset_id", "t"])
+            .reindex(columns=["share", "log_return"])
+        )
+
+        result = merge(
+            household.reset_index(),
+            log_return.reset_index(),
+            on=["asset_id"],
+            how="outer",
+        ).set_index(["household_id", "asset_id", "t"])
+
+        tm.assert_frame_equal(result, expected)
+
+
+class TestJoinMultiMulti:
+    def test_join_multi_multi(
+        self, left_multi, right_multi, join_type, on_cols_multi, idx_cols_multi
+    ):
+        # Multi-index join tests
+        expected = (
+            merge(
+                left_multi.reset_index(),
+                right_multi.reset_index(),
+                how=join_type,
+                on=on_cols_multi,
+            )
+            .set_index(idx_cols_multi)
+            .sort_index()
+        )
+
+        result = left_multi.join(right_multi, how=join_type).sort_index()
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_multi_empty_frames(
+        self, left_multi, right_multi, join_type, on_cols_multi, idx_cols_multi
+    ):
+        left_multi = left_multi.drop(columns=left_multi.columns)
+        right_multi = right_multi.drop(columns=right_multi.columns)
+
+        expected = (
+            merge(
+                left_multi.reset_index(),
+                right_multi.reset_index(),
+                how=join_type,
+                on=on_cols_multi,
+            )
+            .set_index(idx_cols_multi)
+            .sort_index()
+        )
+
+        result = left_multi.join(right_multi, how=join_type).sort_index()
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("box", [None, np.asarray, Series, Index])
+    def test_merge_datetime_index(self, box):
+        # see gh-19038
+        df = DataFrame(
+            [1, 2, 3], ["2016-01-01", "2017-01-01", "2018-01-01"], columns=["a"]
+        )
+        df.index = pd.to_datetime(df.index)
+        on_vector = df.index.year
+
+        if box is not None:
+            on_vector = box(on_vector)
+
+        exp_years = np.array([2016, 2017, 2018], dtype=np.int32)
+        expected = DataFrame({"a": [1, 2, 3], "key_1": exp_years})
+
+        result = df.merge(df, on=["a", on_vector], how="inner")
+        tm.assert_frame_equal(result, expected)
+
+        expected = DataFrame({"key_0": exp_years, "a_x": [1, 2, 3], "a_y": [1, 2, 3]})
+
+        result = df.merge(df, on=[df.index.year], how="inner")
+        tm.assert_frame_equal(result, expected)
+
+    def test_single_common_level(self):
+        index_left = MultiIndex.from_tuples(
+            [("K0", "X0"), ("K0", "X1"), ("K1", "X2")], names=["key", "X"]
+        )
+
+        left = DataFrame(
+            {"A": ["A0", "A1", "A2"], "B": ["B0", "B1", "B2"]}, index=index_left
+        )
+
+        index_right = MultiIndex.from_tuples(
+            [("K0", "Y0"), ("K1", "Y1"), ("K2", "Y2"), ("K2", "Y3")], names=["key", "Y"]
+        )
+
+        right = DataFrame(
+            {"C": ["C0", "C1", "C2", "C3"], "D": ["D0", "D1", "D2", "D3"]},
+            index=index_right,
+        )
+
+        result = left.join(right)
+        expected = merge(
+            left.reset_index(), right.reset_index(), on=["key"], how="inner"
+        ).set_index(["key", "X", "Y"])
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_join_multi_wrong_order(self):
+        # GH 25760
+        # GH 28956
+
+        midx1 = MultiIndex.from_product([[1, 2], [3, 4]], names=["a", "b"])
+        midx3 = MultiIndex.from_tuples([(4, 1), (3, 2), (3, 1)], names=["b", "a"])
+
+        left = DataFrame(index=midx1, data={"x": [10, 20, 30, 40]})
+        right = DataFrame(index=midx3, data={"y": ["foo", "bar", "fing"]})
+
+        result = left.join(right)
+
+        expected = DataFrame(
+            index=midx1,
+            data={"x": [10, 20, 30, 40], "y": ["fing", "foo", "bar", np.nan]},
+        )
+
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f62a0ab050f4310ea400893dcc5ecd167c952c67
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_api.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_api.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6111be92909bdafe767b2796c9de9191e1fa1ee7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_api.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_arithmetic.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_arithmetic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..654d26bec2642c01349ed2d9da7cb84f16801898
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_arithmetic.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9aae733dd801223161bf6c34b48335978828b56
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ef575872f4aed44988f1b4bb37005e29a80e7091068c198e2729d5408604667
+size 133479
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_cumulative.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_cumulative.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87b6c368be30427827a6f3efc9fbda6ecb595998
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_cumulative.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_iteration.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_iteration.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ebf9a296fad8e01312a01e3383f3d80f3e6aa7b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_iteration.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_logical_ops.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_logical_ops.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b29695d22f5c4006a321251c1b3d7843653f48d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_logical_ops.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_missing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_missing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0de028dca57421a38905472d52d1f3f05aa34f2f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_missing.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_npfuncs.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_npfuncs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44894a1225d83a349130984386ed44d511454956
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_npfuncs.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_reductions.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_reductions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..646bbf1bfc4b05591b12656f70b18d4b9367047a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_reductions.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_repr.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_repr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c96c5d0eefca737c09a5f374765a50fb091ce64
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_repr.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_subclass.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_subclass.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc5a17cf391845456310fe15482f3349608c554b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_subclass.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_ufunc.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_ufunc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5903c58fbf800e169d101eef60da4c558b4fe4c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_ufunc.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_unary.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_unary.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..396985801f71e60754a21f9a669f40ff550b6c80
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_unary.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_validate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_validate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7e20cb0ccf5512b7714b675430e38229ffacd4e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/__pycache__/test_validate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a30a7be300c5b58ed298ef5ca89ba96f4d9aee6c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb60704b5b4d2f1621b73bd03ed0b22216bbebe2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_cat_accessor.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_dt_accessor.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_dt_accessor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b35b6abdc8514debc357f54bb924f9af11d78f25
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_dt_accessor.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..447890cc82b4924c4ac9e46ccbd71d3b4b8045b5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_sparse_accessor.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_str_accessor.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_str_accessor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4394ab546b5c1ed1e21235a6729cd28352fa5035
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/__pycache__/test_str_accessor.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_cat_accessor.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_cat_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d50b0f36904a94e7e16aac426e1d098fe320c94
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_cat_accessor.py
@@ -0,0 +1,258 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays.categorical import CategoricalAccessor
+from pandas.core.indexes.accessors import Properties
+
+
+class TestCatAccessor:
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.cat.set_categories([1, 2, 3]),
+            lambda x: x.cat.reorder_categories([2, 3, 1], ordered=True),
+            lambda x: x.cat.rename_categories([1, 2, 3]),
+            lambda x: x.cat.remove_unused_categories(),
+            lambda x: x.cat.remove_categories([2]),
+            lambda x: x.cat.add_categories([4]),
+            lambda x: x.cat.as_ordered(),
+            lambda x: x.cat.as_unordered(),
+        ],
+    )
+    def test_getname_categorical_accessor(self, method):
+        # GH#17509
+        ser = Series([1, 2, 3], name="A").astype("category")
+        expected = "A"
+        result = method(ser).name
+        assert result == expected
+
+    def test_cat_accessor(self):
+        ser = Series(Categorical(["a", "b", np.nan, "a"]))
+        tm.assert_index_equal(ser.cat.categories, Index(["a", "b"]))
+        assert not ser.cat.ordered, False
+
+        exp = Categorical(["a", "b", np.nan, "a"], categories=["b", "a"])
+
+        res = ser.cat.set_categories(["b", "a"])
+        tm.assert_categorical_equal(res.values, exp)
+
+        ser[:] = "a"
+        ser = ser.cat.remove_unused_categories()
+        tm.assert_index_equal(ser.cat.categories, Index(["a"]))
+
+    def test_cat_accessor_api(self):
+        # GH#9322
+
+        assert Series.cat is CategoricalAccessor
+        ser = Series(list("aabbcde")).astype("category")
+        assert isinstance(ser.cat, CategoricalAccessor)
+
+        invalid = Series([1])
+        with pytest.raises(AttributeError, match="only use .cat accessor"):
+            invalid.cat
+        assert not hasattr(invalid, "cat")
+
+    def test_cat_accessor_no_new_attributes(self):
+        # https://github.com/pandas-dev/pandas/issues/10673
+        cat = Series(list("aabbcde")).astype("category")
+        with pytest.raises(AttributeError, match="You cannot add any new attribute"):
+            cat.cat.xlabel = "a"
+
+    def test_categorical_delegations(self):
+        # invalid accessor
+        msg = r"Can only use \.cat accessor with a 'category' dtype"
+        with pytest.raises(AttributeError, match=msg):
+            Series([1, 2, 3]).cat
+        with pytest.raises(AttributeError, match=msg):
+            Series([1, 2, 3]).cat()
+        with pytest.raises(AttributeError, match=msg):
+            Series(["a", "b", "c"]).cat
+        with pytest.raises(AttributeError, match=msg):
+            Series(np.arange(5.0)).cat
+        with pytest.raises(AttributeError, match=msg):
+            Series([Timestamp("20130101")]).cat
+
+        # Series should delegate calls to '.categories', '.codes', '.ordered'
+        # and the methods '.set_categories()' 'drop_unused_categories()' to the
+        # categorical
+        ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
+        exp_categories = Index(["a", "b", "c"])
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+        ser = ser.cat.rename_categories([1, 2, 3])
+        exp_categories = Index([1, 2, 3])
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+
+        exp_codes = Series([0, 1, 2, 0], dtype="int8")
+        tm.assert_series_equal(ser.cat.codes, exp_codes)
+
+        assert ser.cat.ordered
+        ser = ser.cat.as_unordered()
+        assert not ser.cat.ordered
+
+        ser = ser.cat.as_ordered()
+        assert ser.cat.ordered
+
+        # reorder
+        ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
+        exp_categories = Index(["c", "b", "a"])
+        exp_values = np.array(["a", "b", "c", "a"], dtype=np.object_)
+        ser = ser.cat.set_categories(["c", "b", "a"])
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+        tm.assert_numpy_array_equal(ser.values.__array__(), exp_values)
+        tm.assert_numpy_array_equal(ser.__array__(), exp_values)
+
+        # remove unused categories
+        ser = Series(Categorical(["a", "b", "b", "a"], categories=["a", "b", "c"]))
+        exp_categories = Index(["a", "b"])
+        exp_values = np.array(["a", "b", "b", "a"], dtype=np.object_)
+        ser = ser.cat.remove_unused_categories()
+        tm.assert_index_equal(ser.cat.categories, exp_categories)
+        tm.assert_numpy_array_equal(ser.values.__array__(), exp_values)
+        tm.assert_numpy_array_equal(ser.__array__(), exp_values)
+
+        # This method is likely to be confused, so test that it raises an error
+        # on wrong inputs:
+        msg = "'Series' object has no attribute 'set_categories'"
+        with pytest.raises(AttributeError, match=msg):
+            ser.set_categories([4, 3, 2, 1])
+
+        # right: ser.cat.set_categories([4,3,2,1])
+
+        # GH#18862 (let Series.cat.rename_categories take callables)
+        ser = Series(Categorical(["a", "b", "c", "a"], ordered=True))
+        result = ser.cat.rename_categories(lambda x: x.upper())
+        expected = Series(
+            Categorical(["A", "B", "C", "A"], categories=["A", "B", "C"], ordered=True)
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            date_range("1/1/2015", periods=5),
+            date_range("1/1/2015", periods=5, tz="MET"),
+            period_range("1/1/2015", freq="D", periods=5),
+            timedelta_range("1 days", "10 days"),
+        ],
+    )
+    def test_dt_accessor_api_for_categorical(self, idx):
+        # https://github.com/pandas-dev/pandas/issues/10661
+
+        ser = Series(idx)
+        cat = ser.astype("category")
+
+        # only testing field (like .day)
+        # and bool (is_month_start)
+        attr_names = type(ser._values)._datetimelike_ops
+
+        assert isinstance(cat.dt, Properties)
+
+        special_func_defs = [
+            ("strftime", ("%Y-%m-%d",), {}),
+            ("round", ("D",), {}),
+            ("floor", ("D",), {}),
+            ("ceil", ("D",), {}),
+            ("asfreq", ("D",), {}),
+            ("as_unit", ("s"), {}),
+        ]
+        if idx.dtype == "M8[ns]":
+            # exclude dt64tz since that is already localized and would raise
+            tup = ("tz_localize", ("UTC",), {})
+            special_func_defs.append(tup)
+        elif idx.dtype.kind == "M":
+            # exclude dt64 since that is not localized so would raise
+            tup = ("tz_convert", ("EST",), {})
+            special_func_defs.append(tup)
+
+        _special_func_names = [f[0] for f in special_func_defs]
+
+        _ignore_names = ["components", "tz_localize", "tz_convert"]
+
+        func_names = [
+            fname
+            for fname in dir(ser.dt)
+            if not (
+                fname.startswith("_")
+                or fname in attr_names
+                or fname in _special_func_names
+                or fname in _ignore_names
+            )
+        ]
+
+        func_defs = [(fname, (), {}) for fname in func_names]
+        func_defs.extend(
+            f_def for f_def in special_func_defs if f_def[0] in dir(ser.dt)
+        )
+
+        for func, args, kwargs in func_defs:
+            warn_cls = []
+            if func == "to_period" and getattr(idx, "tz", None) is not None:
+                # dropping TZ
+                warn_cls.append(UserWarning)
+            if func == "to_pydatetime":
+                # deprecated to return Index[object]
+                warn_cls.append(FutureWarning)
+            if warn_cls:
+                warn_cls = tuple(warn_cls)
+            else:
+                warn_cls = None
+            with tm.assert_produces_warning(warn_cls):
+                res = getattr(cat.dt, func)(*args, **kwargs)
+                exp = getattr(ser.dt, func)(*args, **kwargs)
+
+            tm.assert_equal(res, exp)
+
+        for attr in attr_names:
+            res = getattr(cat.dt, attr)
+            exp = getattr(ser.dt, attr)
+
+            tm.assert_equal(res, exp)
+
+    def test_dt_accessor_api_for_categorical_invalid(self):
+        invalid = Series([1, 2, 3]).astype("category")
+        msg = "Can only use .dt accessor with datetimelike"
+
+        with pytest.raises(AttributeError, match=msg):
+            invalid.dt
+        assert not hasattr(invalid, "str")
+
+    def test_set_categories_setitem(self):
+        # GH#43334
+
+        df = DataFrame({"Survived": [1, 0, 1], "Sex": [0, 1, 1]}, dtype="category")
+
+        df["Survived"] = df["Survived"].cat.rename_categories(["No", "Yes"])
+        df["Sex"] = df["Sex"].cat.rename_categories(["female", "male"])
+
+        # values should not be coerced to NaN
+        assert list(df["Sex"]) == ["female", "male", "male"]
+        assert list(df["Survived"]) == ["Yes", "No", "Yes"]
+
+        df["Sex"] = Categorical(df["Sex"], categories=["female", "male"], ordered=False)
+        df["Survived"] = Categorical(
+            df["Survived"], categories=["No", "Yes"], ordered=False
+        )
+
+        # values should not be coerced to NaN
+        assert list(df["Sex"]) == ["female", "male", "male"]
+        assert list(df["Survived"]) == ["Yes", "No", "Yes"]
+
+    def test_categorical_of_booleans_is_boolean(self):
+        # https://github.com/pandas-dev/pandas/issues/46313
+        df = DataFrame(
+            {"int_cat": [1, 2, 3], "bool_cat": [True, False, False]}, dtype="category"
+        )
+        value = df["bool_cat"].cat.categories.dtype
+        expected = np.dtype(np.bool_)
+        assert value is expected
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_dt_accessor.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_dt_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd810a31c25af45e8519d4e93f44130b93114729
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_dt_accessor.py
@@ -0,0 +1,836 @@
+import calendar
+from datetime import (
+    date,
+    datetime,
+    time,
+)
+import locale
+import unicodedata
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs.timezones import maybe_get_tz
+from pandas.errors import SettingWithCopyError
+
+from pandas.core.dtypes.common import (
+    is_integer_dtype,
+    is_list_like,
+)
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Period,
+    PeriodIndex,
+    Series,
+    TimedeltaIndex,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    PeriodArray,
+    TimedeltaArray,
+)
+
+ok_for_period = PeriodArray._datetimelike_ops
+ok_for_period_methods = ["strftime", "to_timestamp", "asfreq"]
+ok_for_dt = DatetimeArray._datetimelike_ops
+ok_for_dt_methods = [
+    "to_period",
+    "to_pydatetime",
+    "tz_localize",
+    "tz_convert",
+    "normalize",
+    "strftime",
+    "round",
+    "floor",
+    "ceil",
+    "day_name",
+    "month_name",
+    "isocalendar",
+    "as_unit",
+]
+ok_for_td = TimedeltaArray._datetimelike_ops
+ok_for_td_methods = [
+    "components",
+    "to_pytimedelta",
+    "total_seconds",
+    "round",
+    "floor",
+    "ceil",
+    "as_unit",
+]
+
+
+def get_dir(ser):
+    # check limited display api
+    results = [r for r in ser.dt.__dir__() if not r.startswith("_")]
+    return sorted(set(results))
+
+
+class TestSeriesDatetimeValues:
+    def _compare(self, ser, name):
+        # GH 7207, 11128
+        # test .dt namespace accessor
+
+        def get_expected(ser, prop):
+            result = getattr(Index(ser._values), prop)
+            if isinstance(result, np.ndarray):
+                if is_integer_dtype(result):
+                    result = result.astype("int64")
+            elif not is_list_like(result) or isinstance(result, DataFrame):
+                return result
+            return Series(result, index=ser.index, name=ser.name)
+
+        left = getattr(ser.dt, name)
+        right = get_expected(ser, name)
+        if not (is_list_like(left) and is_list_like(right)):
+            assert left == right
+        elif isinstance(left, DataFrame):
+            tm.assert_frame_equal(left, right)
+        else:
+            tm.assert_series_equal(left, right)
+
+    @pytest.mark.parametrize("freq", ["D", "s", "ms"])
+    def test_dt_namespace_accessor_datetime64(self, freq):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # datetimeindex
+        dti = date_range("20130101", periods=5, freq=freq)
+        ser = Series(dti, name="xxx")
+
+        for prop in ok_for_dt:
+            # we test freq below
+            if prop != "freq":
+                self._compare(ser, prop)
+
+        for prop in ok_for_dt_methods:
+            getattr(ser.dt, prop)
+
+        msg = "The behavior of DatetimeProperties.to_pydatetime is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.dt.to_pydatetime()
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == object
+
+        result = ser.dt.tz_localize("US/Eastern")
+        exp_values = DatetimeIndex(ser.values).tz_localize("US/Eastern")
+        expected = Series(exp_values, index=ser.index, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+        tz_result = result.dt.tz
+        assert str(tz_result) == "US/Eastern"
+        freq_result = ser.dt.freq
+        assert freq_result == DatetimeIndex(ser.values, freq="infer").freq
+
+        # let's localize, then convert
+        result = ser.dt.tz_localize("UTC").dt.tz_convert("US/Eastern")
+        exp_values = (
+            DatetimeIndex(ser.values).tz_localize("UTC").tz_convert("US/Eastern")
+        )
+        expected = Series(exp_values, index=ser.index, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_namespace_accessor_datetime64tz(self):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # datetimeindex with tz
+        dti = date_range("20130101", periods=5, tz="US/Eastern")
+        ser = Series(dti, name="xxx")
+        for prop in ok_for_dt:
+            # we test freq below
+            if prop != "freq":
+                self._compare(ser, prop)
+
+        for prop in ok_for_dt_methods:
+            getattr(ser.dt, prop)
+
+        msg = "The behavior of DatetimeProperties.to_pydatetime is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.dt.to_pydatetime()
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == object
+
+        result = ser.dt.tz_convert("CET")
+        expected = Series(ser._values.tz_convert("CET"), index=ser.index, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+        tz_result = result.dt.tz
+        assert str(tz_result) == "CET"
+        freq_result = ser.dt.freq
+        assert freq_result == DatetimeIndex(ser.values, freq="infer").freq
+
+    def test_dt_namespace_accessor_timedelta(self):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # timedelta index
+        cases = [
+            Series(
+                timedelta_range("1 day", periods=5), index=list("abcde"), name="xxx"
+            ),
+            Series(timedelta_range("1 day 01:23:45", periods=5, freq="s"), name="xxx"),
+            Series(
+                timedelta_range("2 days 01:23:45.012345", periods=5, freq="ms"),
+                name="xxx",
+            ),
+        ]
+        for ser in cases:
+            for prop in ok_for_td:
+                # we test freq below
+                if prop != "freq":
+                    self._compare(ser, prop)
+
+            for prop in ok_for_td_methods:
+                getattr(ser.dt, prop)
+
+            result = ser.dt.components
+            assert isinstance(result, DataFrame)
+            tm.assert_index_equal(result.index, ser.index)
+
+            result = ser.dt.to_pytimedelta()
+            assert isinstance(result, np.ndarray)
+            assert result.dtype == object
+
+            result = ser.dt.total_seconds()
+            assert isinstance(result, Series)
+            assert result.dtype == "float64"
+
+            freq_result = ser.dt.freq
+            assert freq_result == TimedeltaIndex(ser.values, freq="infer").freq
+
+    def test_dt_namespace_accessor_period(self):
+        # GH#7207, GH#11128
+        # test .dt namespace accessor
+
+        # periodindex
+        pi = period_range("20130101", periods=5, freq="D")
+        ser = Series(pi, name="xxx")
+
+        for prop in ok_for_period:
+            # we test freq below
+            if prop != "freq":
+                self._compare(ser, prop)
+
+        for prop in ok_for_period_methods:
+            getattr(ser.dt, prop)
+
+        freq_result = ser.dt.freq
+        assert freq_result == PeriodIndex(ser.values).freq
+
+    def test_dt_namespace_accessor_index_and_values(self):
+        # both
+        index = date_range("20130101", periods=3, freq="D")
+        dti = date_range("20140204", periods=3, freq="s")
+        ser = Series(dti, index=index, name="xxx")
+        exp = Series(
+            np.array([2014, 2014, 2014], dtype="int32"), index=index, name="xxx"
+        )
+        tm.assert_series_equal(ser.dt.year, exp)
+
+        exp = Series(np.array([2, 2, 2], dtype="int32"), index=index, name="xxx")
+        tm.assert_series_equal(ser.dt.month, exp)
+
+        exp = Series(np.array([0, 1, 2], dtype="int32"), index=index, name="xxx")
+        tm.assert_series_equal(ser.dt.second, exp)
+
+        exp = Series([ser.iloc[0]] * 3, index=index, name="xxx")
+        tm.assert_series_equal(ser.dt.normalize(), exp)
+
+    def test_dt_accessor_limited_display_api(self):
+        # tznaive
+        ser = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
+        results = get_dir(ser)
+        tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
+
+        # tzaware
+        ser = Series(date_range("2015-01-01", "2016-01-01", freq="T"), name="xxx")
+        ser = ser.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
+        results = get_dir(ser)
+        tm.assert_almost_equal(results, sorted(set(ok_for_dt + ok_for_dt_methods)))
+
+        # Period
+        ser = Series(
+            period_range("20130101", periods=5, freq="D", name="xxx").astype(object)
+        )
+        results = get_dir(ser)
+        tm.assert_almost_equal(
+            results, sorted(set(ok_for_period + ok_for_period_methods))
+        )
+
+    def test_dt_accessor_ambiguous_freq_conversions(self):
+        # GH#11295
+        # ambiguous time error on the conversions
+        ser = Series(date_range("2015-01-01", "2016-01-01", freq="T"), name="xxx")
+        ser = ser.dt.tz_localize("UTC").dt.tz_convert("America/Chicago")
+
+        exp_values = date_range(
+            "2015-01-01", "2016-01-01", freq="T", tz="UTC"
+        ).tz_convert("America/Chicago")
+        # freq not preserved by tz_localize above
+        exp_values = exp_values._with_freq(None)
+        expected = Series(exp_values, name="xxx")
+        tm.assert_series_equal(ser, expected)
+
+    def test_dt_accessor_not_writeable(self, using_copy_on_write):
+        # no setting allowed
+        ser = Series(date_range("20130101", periods=5, freq="D"), name="xxx")
+        with pytest.raises(ValueError, match="modifications"):
+            ser.dt.hour = 5
+
+        # trying to set a copy
+        msg = "modifications to a property of a datetimelike.+not supported"
+        with pd.option_context("chained_assignment", "raise"):
+            if using_copy_on_write:
+                with tm.raises_chained_assignment_error():
+                    ser.dt.hour[0] = 5
+            else:
+                with pytest.raises(SettingWithCopyError, match=msg):
+                    ser.dt.hour[0] = 5
+
+    @pytest.mark.parametrize(
+        "method, dates",
+        [
+            ["round", ["2012-01-02", "2012-01-02", "2012-01-01"]],
+            ["floor", ["2012-01-01", "2012-01-01", "2012-01-01"]],
+            ["ceil", ["2012-01-02", "2012-01-02", "2012-01-02"]],
+        ],
+    )
+    def test_dt_round(self, method, dates):
+        # round
+        ser = Series(
+            pd.to_datetime(
+                ["2012-01-01 13:00:00", "2012-01-01 12:01:00", "2012-01-01 08:00:00"]
+            ),
+            name="xxx",
+        )
+        result = getattr(ser.dt, method)("D")
+        expected = Series(pd.to_datetime(dates), name="xxx")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_round_tz(self):
+        ser = Series(
+            pd.to_datetime(
+                ["2012-01-01 13:00:00", "2012-01-01 12:01:00", "2012-01-01 08:00:00"]
+            ),
+            name="xxx",
+        )
+        result = ser.dt.tz_localize("UTC").dt.tz_convert("US/Eastern").dt.round("D")
+
+        exp_values = pd.to_datetime(
+            ["2012-01-01", "2012-01-01", "2012-01-01"]
+        ).tz_localize("US/Eastern")
+        expected = Series(exp_values, name="xxx")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("method", ["ceil", "round", "floor"])
+    def test_dt_round_tz_ambiguous(self, method):
+        # GH 18946 round near "fall back" DST
+        df1 = DataFrame(
+            [
+                pd.to_datetime("2017-10-29 02:00:00+02:00", utc=True),
+                pd.to_datetime("2017-10-29 02:00:00+01:00", utc=True),
+                pd.to_datetime("2017-10-29 03:00:00+01:00", utc=True),
+            ],
+            columns=["date"],
+        )
+        df1["date"] = df1["date"].dt.tz_convert("Europe/Madrid")
+        # infer
+        result = getattr(df1.date.dt, method)("H", ambiguous="infer")
+        expected = df1["date"]
+        tm.assert_series_equal(result, expected)
+
+        # bool-array
+        result = getattr(df1.date.dt, method)("H", ambiguous=[True, False, False])
+        tm.assert_series_equal(result, expected)
+
+        # NaT
+        result = getattr(df1.date.dt, method)("H", ambiguous="NaT")
+        expected = df1["date"].copy()
+        expected.iloc[0:2] = pd.NaT
+        tm.assert_series_equal(result, expected)
+
+        # raise
+        with tm.external_error_raised(pytz.AmbiguousTimeError):
+            getattr(df1.date.dt, method)("H", ambiguous="raise")
+
+    @pytest.mark.parametrize(
+        "method, ts_str, freq",
+        [
+            ["ceil", "2018-03-11 01:59:00-0600", "5min"],
+            ["round", "2018-03-11 01:59:00-0600", "5min"],
+            ["floor", "2018-03-11 03:01:00-0500", "2H"],
+        ],
+    )
+    def test_dt_round_tz_nonexistent(self, method, ts_str, freq):
+        # GH 23324 round near "spring forward" DST
+        ser = Series([pd.Timestamp(ts_str, tz="America/Chicago")])
+        result = getattr(ser.dt, method)(freq, nonexistent="shift_forward")
+        expected = Series([pd.Timestamp("2018-03-11 03:00:00", tz="America/Chicago")])
+        tm.assert_series_equal(result, expected)
+
+        result = getattr(ser.dt, method)(freq, nonexistent="NaT")
+        expected = Series([pd.NaT]).dt.tz_localize(result.dt.tz)
+        tm.assert_series_equal(result, expected)
+
+        with pytest.raises(pytz.NonExistentTimeError, match="2018-03-11 02:00:00"):
+            getattr(ser.dt, method)(freq, nonexistent="raise")
+
+    @pytest.mark.parametrize("freq", ["ns", "U", "1000U"])
+    def test_dt_round_nonnano_higher_resolution_no_op(self, freq):
+        # GH 52761
+        ser = Series(
+            ["2020-05-31 08:00:00", "2000-12-31 04:00:05", "1800-03-14 07:30:20"],
+            dtype="datetime64[ms]",
+        )
+        expected = ser.copy()
+        result = ser.dt.round(freq)
+        tm.assert_series_equal(result, expected)
+
+        assert not np.shares_memory(ser.array._ndarray, result.array._ndarray)
+
+    def test_dt_namespace_accessor_categorical(self):
+        # GH 19468
+        dti = DatetimeIndex(["20171111", "20181212"]).repeat(2)
+        ser = Series(pd.Categorical(dti), name="foo")
+        result = ser.dt.year
+        expected = Series([2017, 2017, 2018, 2018], dtype="int32", name="foo")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_tz_localize_categorical(self, tz_aware_fixture):
+        # GH 27952
+        tz = tz_aware_fixture
+        datetimes = Series(
+            ["2019-01-01", "2019-01-01", "2019-01-02"], dtype="datetime64[ns]"
+        )
+        categorical = datetimes.astype("category")
+        result = categorical.dt.tz_localize(tz)
+        expected = datetimes.dt.tz_localize(tz)
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_tz_convert_categorical(self, tz_aware_fixture):
+        # GH 27952
+        tz = tz_aware_fixture
+        datetimes = Series(
+            ["2019-01-01", "2019-01-01", "2019-01-02"], dtype="datetime64[ns, MET]"
+        )
+        categorical = datetimes.astype("category")
+        result = categorical.dt.tz_convert(tz)
+        expected = datetimes.dt.tz_convert(tz)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("accessor", ["year", "month", "day"])
+    def test_dt_other_accessors_categorical(self, accessor):
+        # GH 27952
+        datetimes = Series(
+            ["2018-01-01", "2018-01-01", "2019-01-02"], dtype="datetime64[ns]"
+        )
+        categorical = datetimes.astype("category")
+        result = getattr(categorical.dt, accessor)
+        expected = getattr(datetimes.dt, accessor)
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_accessor_no_new_attributes(self):
+        # https://github.com/pandas-dev/pandas/issues/10673
+        ser = Series(date_range("20130101", periods=5, freq="D"))
+        with pytest.raises(AttributeError, match="You cannot add any new attribute"):
+            ser.dt.xlabel = "a"
+
+    # error: Unsupported operand types for + ("List[None]" and "List[str]")
+    @pytest.mark.parametrize(
+        "time_locale", [None] + tm.get_locales()  # type: ignore[operator]
+    )
+    def test_dt_accessor_datetime_name_accessors(self, time_locale):
+        # Test Monday -> Sunday and January -> December, in that sequence
+        if time_locale is None:
+            # If the time_locale is None, day-name and month_name should
+            # return the english attributes
+            expected_days = [
+                "Monday",
+                "Tuesday",
+                "Wednesday",
+                "Thursday",
+                "Friday",
+                "Saturday",
+                "Sunday",
+            ]
+            expected_months = [
+                "January",
+                "February",
+                "March",
+                "April",
+                "May",
+                "June",
+                "July",
+                "August",
+                "September",
+                "October",
+                "November",
+                "December",
+            ]
+        else:
+            with tm.set_locale(time_locale, locale.LC_TIME):
+                expected_days = calendar.day_name[:]
+                expected_months = calendar.month_name[1:]
+
+        ser = Series(date_range(freq="D", start=datetime(1998, 1, 1), periods=365))
+        english_days = [
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "Sunday",
+        ]
+        for day, name, eng_name in zip(range(4, 11), expected_days, english_days):
+            name = name.capitalize()
+            assert ser.dt.day_name(locale=time_locale)[day] == name
+            assert ser.dt.day_name(locale=None)[day] == eng_name
+        ser = pd.concat([ser, Series([pd.NaT])])
+        assert np.isnan(ser.dt.day_name(locale=time_locale).iloc[-1])
+
+        ser = Series(date_range(freq="M", start="2012", end="2013"))
+        result = ser.dt.month_name(locale=time_locale)
+        expected = Series([month.capitalize() for month in expected_months])
+
+        # work around https://github.com/pandas-dev/pandas/issues/22342
+        result = result.str.normalize("NFD")
+        expected = expected.str.normalize("NFD")
+
+        tm.assert_series_equal(result, expected)
+
+        for s_date, expected in zip(ser, expected_months):
+            result = s_date.month_name(locale=time_locale)
+            expected = expected.capitalize()
+
+            result = unicodedata.normalize("NFD", result)
+            expected = unicodedata.normalize("NFD", expected)
+
+            assert result == expected
+
+        ser = pd.concat([ser, Series([pd.NaT])])
+        assert np.isnan(ser.dt.month_name(locale=time_locale).iloc[-1])
+
+    def test_strftime(self):
+        # GH 10086
+        ser = Series(date_range("20130101", periods=5))
+        result = ser.dt.strftime("%Y/%m/%d")
+        expected = Series(
+            ["2013/01/01", "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(date_range("2015-02-03 11:22:33.4567", periods=5))
+        result = ser.dt.strftime("%Y/%m/%d %H-%M-%S")
+        expected = Series(
+            [
+                "2015/02/03 11-22-33",
+                "2015/02/04 11-22-33",
+                "2015/02/05 11-22-33",
+                "2015/02/06 11-22-33",
+                "2015/02/07 11-22-33",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(period_range("20130101", periods=5))
+        result = ser.dt.strftime("%Y/%m/%d")
+        expected = Series(
+            ["2013/01/01", "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(period_range("2015-02-03 11:22:33.4567", periods=5, freq="s"))
+        result = ser.dt.strftime("%Y/%m/%d %H-%M-%S")
+        expected = Series(
+            [
+                "2015/02/03 11-22-33",
+                "2015/02/03 11-22-34",
+                "2015/02/03 11-22-35",
+                "2015/02/03 11-22-36",
+                "2015/02/03 11-22-37",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_strftime_dt64_days(self):
+        ser = Series(date_range("20130101", periods=5))
+        ser.iloc[0] = pd.NaT
+        result = ser.dt.strftime("%Y/%m/%d")
+        expected = Series(
+            [np.nan, "2013/01/02", "2013/01/03", "2013/01/04", "2013/01/05"]
+        )
+        tm.assert_series_equal(result, expected)
+
+        datetime_index = date_range("20150301", periods=5)
+        result = datetime_index.strftime("%Y/%m/%d")
+
+        expected = Index(
+            ["2015/03/01", "2015/03/02", "2015/03/03", "2015/03/04", "2015/03/05"],
+            dtype=np.object_,
+        )
+        # dtype may be S10 or U10 depending on python version
+        tm.assert_index_equal(result, expected)
+
+    def test_strftime_period_days(self):
+        period_index = period_range("20150301", periods=5)
+        result = period_index.strftime("%Y/%m/%d")
+        expected = Index(
+            ["2015/03/01", "2015/03/02", "2015/03/03", "2015/03/04", "2015/03/05"],
+            dtype="=U10",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_strftime_dt64_microsecond_resolution(self):
+        ser = Series([datetime(2013, 1, 1, 2, 32, 59), datetime(2013, 1, 2, 14, 32, 1)])
+        result = ser.dt.strftime("%Y-%m-%d %H:%M:%S")
+        expected = Series(["2013-01-01 02:32:59", "2013-01-02 14:32:01"])
+        tm.assert_series_equal(result, expected)
+
+    def test_strftime_period_hours(self):
+        ser = Series(period_range("20130101", periods=4, freq="H"))
+        result = ser.dt.strftime("%Y/%m/%d %H:%M:%S")
+        expected = Series(
+            [
+                "2013/01/01 00:00:00",
+                "2013/01/01 01:00:00",
+                "2013/01/01 02:00:00",
+                "2013/01/01 03:00:00",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_strftime_period_minutes(self):
+        ser = Series(period_range("20130101", periods=4, freq="L"))
+        result = ser.dt.strftime("%Y/%m/%d %H:%M:%S.%l")
+        expected = Series(
+            [
+                "2013/01/01 00:00:00.000",
+                "2013/01/01 00:00:00.001",
+                "2013/01/01 00:00:00.002",
+                "2013/01/01 00:00:00.003",
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            DatetimeIndex(["2019-01-01", pd.NaT]),
+            PeriodIndex(["2019-01-01", pd.NaT], dtype="period[D]"),
+        ],
+    )
+    def test_strftime_nat(self, data):
+        # GH 29578
+        ser = Series(data)
+        result = ser.dt.strftime("%Y-%m-%d")
+        expected = Series(["2019-01-01", np.nan])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data", [DatetimeIndex([pd.NaT]), PeriodIndex([pd.NaT], dtype="period[D]")]
+    )
+    def test_strftime_all_nat(self, data):
+        # https://github.com/pandas-dev/pandas/issues/45858
+        ser = Series(data)
+        with tm.assert_produces_warning(None):
+            result = ser.dt.strftime("%Y-%m-%d")
+        expected = Series([np.nan], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_valid_dt_with_missing_values(self):
+        # GH 8689
+        ser = Series(date_range("20130101", periods=5, freq="D"))
+        ser.iloc[2] = pd.NaT
+
+        for attr in ["microsecond", "nanosecond", "second", "minute", "hour", "day"]:
+            expected = getattr(ser.dt, attr).copy()
+            expected.iloc[2] = np.nan
+            result = getattr(ser.dt, attr)
+            tm.assert_series_equal(result, expected)
+
+        result = ser.dt.date
+        expected = Series(
+            [
+                date(2013, 1, 1),
+                date(2013, 1, 2),
+                pd.NaT,
+                date(2013, 1, 4),
+                date(2013, 1, 5),
+            ],
+            dtype="object",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = ser.dt.time
+        expected = Series([time(0), time(0), pd.NaT, time(0), time(0)], dtype="object")
+        tm.assert_series_equal(result, expected)
+
+    def test_dt_accessor_api(self):
+        # GH 9322
+        from pandas.core.indexes.accessors import (
+            CombinedDatetimelikeProperties,
+            DatetimeProperties,
+        )
+
+        assert Series.dt is CombinedDatetimelikeProperties
+
+        ser = Series(date_range("2000-01-01", periods=3))
+        assert isinstance(ser.dt, DatetimeProperties)
+
+    @pytest.mark.parametrize(
+        "ser",
+        [
+            Series(np.arange(5)),
+            Series(list("abcde")),
+            Series(np.random.default_rng(2).standard_normal(5)),
+        ],
+    )
+    def test_dt_accessor_invalid(self, ser):
+        # GH#9322 check that series with incorrect dtypes don't have attr
+        with pytest.raises(AttributeError, match="only use .dt accessor"):
+            ser.dt
+        assert not hasattr(ser, "dt")
+
+    def test_dt_accessor_updates_on_inplace(self):
+        ser = Series(date_range("2018-01-01", periods=10))
+        ser[2] = None
+        return_value = ser.fillna(pd.Timestamp("2018-01-01"), inplace=True)
+        assert return_value is None
+        result = ser.dt.date
+        assert result[0] == result[2]
+
+    def test_date_tz(self):
+        # GH11757
+        rng = DatetimeIndex(
+            ["2014-04-04 23:56", "2014-07-18 21:24", "2015-11-22 22:14"],
+            tz="US/Eastern",
+        )
+        ser = Series(rng)
+        expected = Series([date(2014, 4, 4), date(2014, 7, 18), date(2015, 11, 22)])
+        tm.assert_series_equal(ser.dt.date, expected)
+        tm.assert_series_equal(ser.apply(lambda x: x.date()), expected)
+
+    def test_dt_timetz_accessor(self, tz_naive_fixture):
+        # GH21358
+        tz = maybe_get_tz(tz_naive_fixture)
+
+        dtindex = DatetimeIndex(
+            ["2014-04-04 23:56", "2014-07-18 21:24", "2015-11-22 22:14"], tz=tz
+        )
+        ser = Series(dtindex)
+        expected = Series(
+            [time(23, 56, tzinfo=tz), time(21, 24, tzinfo=tz), time(22, 14, tzinfo=tz)]
+        )
+        result = ser.dt.timetz
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input_series, expected_output",
+        [
+            [["2020-01-01"], [[2020, 1, 3]]],
+            [[pd.NaT], [[np.nan, np.nan, np.nan]]],
+            [["2019-12-31", "2019-12-29"], [[2020, 1, 2], [2019, 52, 7]]],
+            [["2010-01-01", pd.NaT], [[2009, 53, 5], [np.nan, np.nan, np.nan]]],
+            # see GH#36032
+            [["2016-01-08", "2016-01-04"], [[2016, 1, 5], [2016, 1, 1]]],
+            [["2016-01-07", "2016-01-01"], [[2016, 1, 4], [2015, 53, 5]]],
+        ],
+    )
+    def test_isocalendar(self, input_series, expected_output):
+        result = pd.to_datetime(Series(input_series)).dt.isocalendar()
+        expected_frame = DataFrame(
+            expected_output, columns=["year", "week", "day"], dtype="UInt32"
+        )
+        tm.assert_frame_equal(result, expected_frame)
+
+    def test_hour_index(self):
+        dt_series = Series(
+            date_range(start="2021-01-01", periods=5, freq="h"),
+            index=[2, 6, 7, 8, 11],
+            dtype="category",
+        )
+        result = dt_series.dt.hour
+        expected = Series(
+            [0, 1, 2, 3, 4],
+            dtype="int32",
+            index=[2, 6, 7, 8, 11],
+        )
+        tm.assert_series_equal(result, expected)
+
+
+class TestSeriesPeriodValuesDtAccessor:
+    @pytest.mark.parametrize(
+        "input_vals",
+        [
+            [Period("2016-01", freq="M"), Period("2016-02", freq="M")],
+            [Period("2016-01-01", freq="D"), Period("2016-01-02", freq="D")],
+            [
+                Period("2016-01-01 00:00:00", freq="H"),
+                Period("2016-01-01 01:00:00", freq="H"),
+            ],
+            [
+                Period("2016-01-01 00:00:00", freq="M"),
+                Period("2016-01-01 00:01:00", freq="M"),
+            ],
+            [
+                Period("2016-01-01 00:00:00", freq="S"),
+                Period("2016-01-01 00:00:01", freq="S"),
+            ],
+        ],
+    )
+    def test_end_time_timevalues(self, input_vals):
+        # GH#17157
+        # Check that the time part of the Period is adjusted by end_time
+        # when using the dt accessor on a Series
+        input_vals = PeriodArray._from_sequence(np.asarray(input_vals))
+
+        ser = Series(input_vals)
+        result = ser.dt.end_time
+        expected = ser.apply(lambda x: x.end_time)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("input_vals", [("2001"), ("NaT")])
+    def test_to_period(self, input_vals):
+        # GH#21205
+        expected = Series([input_vals], dtype="Period[D]")
+        result = Series([input_vals], dtype="datetime64[ns]").dt.to_period("D")
+        tm.assert_series_equal(result, expected)
+
+
+def test_normalize_pre_epoch_dates():
+    # GH: 36294
+    ser = pd.to_datetime(Series(["1969-01-01 09:00:00", "2016-01-01 09:00:00"]))
+    result = ser.dt.normalize()
+    expected = pd.to_datetime(Series(["1969-01-01", "2016-01-01"]))
+    tm.assert_series_equal(result, expected)
+
+
+def test_day_attribute_non_nano_beyond_int32():
+    # GH 52386
+    data = np.array(
+        [
+            136457654736252,
+            134736784364431,
+            245345345545332,
+            223432411,
+            2343241,
+            3634548734,
+            23234,
+        ],
+        dtype="timedelta64[s]",
+    )
+    ser = Series(data)
+    result = ser.dt.days
+    expected = Series([1579371003, 1559453522, 2839645203, 2586, 27, 42066, 0])
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_sparse_accessor.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_sparse_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..118095b5dcdbc4f63ba511feb954673485f34427
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_sparse_accessor.py
@@ -0,0 +1,9 @@
+from pandas import Series
+
+
+class TestSparseAccessor:
+    def test_sparse_accessor_updates_on_inplace(self):
+        ser = Series([1, 1, 2, 3], dtype="Sparse[int]")
+        return_value = ser.drop([0, 1], inplace=True)
+        assert return_value is None
+        assert ser.sparse.density == 1.0
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_str_accessor.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_str_accessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..09d965ef1f32268550bbf35a17f11529545054ed
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/accessors/test_str_accessor.py
@@ -0,0 +1,25 @@
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestStrAccessor:
+    def test_str_attribute(self):
+        # GH#9068
+        methods = ["strip", "rstrip", "lstrip"]
+        ser = Series([" jack", "jill ", " jesse ", "frank"])
+        for method in methods:
+            expected = Series([getattr(str, method)(x) for x in ser.values])
+            tm.assert_series_equal(getattr(Series.str, method)(ser.str), expected)
+
+        # str accessor only valid with string values
+        ser = Series(range(5))
+        with pytest.raises(AttributeError, match="only use .str accessor"):
+            ser.str.repeat(2)
+
+    def test_str_accessor_updates_on_inplace(self):
+        ser = Series(list("abc"))
+        return_value = ser.drop([0], inplace=True)
+        assert return_value is None
+        assert len(ser.str.lower()) == 2
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b928b38d14cda8b3cba7078f7e0baba1883ba10
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_datetime.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_datetime.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18b73b1f76fa4439af7c4d2b8cc9938dd10e1642
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_datetime.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_delitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_delitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8777e8066f1755dd53ebccd314e7945f0f47fbec
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_delitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_get.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_get.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..644f2cccdfb75ef7226c41ea1095a75840f7a72c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_get.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_getitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_getitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a51cecc9c6dfbfaa5832c96707c4811a59c76f90
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_getitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_indexing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_indexing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9fe68d00dafd831b7ef217eecc0d0c0e69c9718a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_indexing.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_mask.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_mask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6c862c9740baf9b6478a67114aa901782dc46cd
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_mask.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_set_value.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_set_value.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fadc78b7f0d484fa2dc763a674e967f0b8ada8df
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_set_value.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_setitem.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_setitem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28f591795004cb9b7cbf6ccb9249cbd095569436
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_setitem.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_take.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_take.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab244f1a786ac6c89a9d4cf1428d802e47a7e6c1
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_take.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_where.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_where.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..564ed44306897101e5e91ca9a4000ca90285b7c2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_where.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_xs.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_xs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdc3d5b5bcdf07c846187f23f50ea764a6b463b3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/__pycache__/test_xs.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_datetime.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_datetime.py
new file mode 100644
index 0000000000000000000000000000000000000000..11d66d4820fe6eaa2f9f0bb33ed65f1d184600ab
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_datetime.py
@@ -0,0 +1,497 @@
+"""
+Also test support for datetime64[ns] in Series / DataFrame
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+import re
+
+from dateutil.tz import (
+    gettz,
+    tzutc,
+)
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs import index as libindex
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+def test_fancy_getitem():
+    dti = date_range(
+        freq="WOM-1FRI", start=datetime(2005, 1, 1), end=datetime(2010, 1, 1)
+    )
+
+    s = Series(np.arange(len(dti)), index=dti)
+
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert s[48] == 48
+    assert s["1/2/2009"] == 48
+    assert s["2009-1-2"] == 48
+    assert s[datetime(2009, 1, 2)] == 48
+    assert s[Timestamp(datetime(2009, 1, 2))] == 48
+    with pytest.raises(KeyError, match=r"^'2009-1-3'$"):
+        s["2009-1-3"]
+    tm.assert_series_equal(
+        s["3/6/2009":"2009-06-05"], s[datetime(2009, 3, 6) : datetime(2009, 6, 5)]
+    )
+
+
+def test_fancy_setitem():
+    dti = date_range(
+        freq="WOM-1FRI", start=datetime(2005, 1, 1), end=datetime(2010, 1, 1)
+    )
+
+    s = Series(np.arange(len(dti)), index=dti)
+
+    msg = "Series.__setitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        s[48] = -1
+    assert s.iloc[48] == -1
+    s["1/2/2009"] = -2
+    assert s.iloc[48] == -2
+    s["1/2/2009":"2009-06-05"] = -3
+    assert (s[48:54] == -3).all()
+
+
+@pytest.mark.parametrize("tz_source", ["pytz", "dateutil"])
+def test_getitem_setitem_datetime_tz(tz_source):
+    if tz_source == "pytz":
+        tzget = pytz.timezone
+    else:
+        # handle special case for utc in dateutil
+        tzget = lambda x: tzutc() if x == "UTC" else gettz(x)
+
+    N = 50
+    # testing with timezone, GH #2785
+    rng = date_range("1/1/1990", periods=N, freq="H", tz=tzget("US/Eastern"))
+    ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+
+    # also test Timestamp tz handling, GH #2789
+    result = ts.copy()
+    result["1990-01-01 09:00:00+00:00"] = 0
+    result["1990-01-01 09:00:00+00:00"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts.copy()
+    result["1990-01-01 03:00:00-06:00"] = 0
+    result["1990-01-01 03:00:00-06:00"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    # repeat with datetimes
+    result = ts.copy()
+    result[datetime(1990, 1, 1, 9, tzinfo=tzget("UTC"))] = 0
+    result[datetime(1990, 1, 1, 9, tzinfo=tzget("UTC"))] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts.copy()
+    dt = Timestamp(1990, 1, 1, 3).tz_localize(tzget("US/Central"))
+    dt = dt.to_pydatetime()
+    result[dt] = 0
+    result[dt] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+
+def test_getitem_setitem_datetimeindex():
+    N = 50
+    # testing with timezone, GH #2785
+    rng = date_range("1/1/1990", periods=N, freq="H", tz="US/Eastern")
+    ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+
+    result = ts["1990-01-01 04:00:00"]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts.copy()
+    result["1990-01-01 04:00:00"] = 0
+    result["1990-01-01 04:00:00"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts["1990-01-01 04:00:00":"1990-01-01 07:00:00"]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = 0
+    result["1990-01-01 04:00:00":"1990-01-01 07:00:00"] = ts[4:8]
+    tm.assert_series_equal(result, ts)
+
+    lb = "1990-01-01 04:00:00"
+    rb = "1990-01-01 07:00:00"
+    # GH#18435 strings get a pass from tzawareness compat
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    lb = "1990-01-01 04:00:00-0500"
+    rb = "1990-01-01 07:00:00-0500"
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    # But we do not give datetimes a pass on tzawareness compat
+    msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+    naive = datetime(1990, 1, 1, 4)
+    for key in [naive, Timestamp(naive), np.datetime64(naive, "ns")]:
+        with pytest.raises(KeyError, match=re.escape(repr(key))):
+            # GH#36148 as of 2.0 we require tzawareness-compat
+            ts[key]
+
+    result = ts.copy()
+    # GH#36148 as of 2.0 we do not ignore tzawareness mismatch in indexing,
+    #  so setting it as a new key casts to object rather than matching
+    #  rng[4]
+    result[naive] = ts.iloc[4]
+    assert result.index.dtype == object
+    tm.assert_index_equal(result.index[:-1], rng.astype(object))
+    assert result.index[-1] == naive
+
+    msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+    with pytest.raises(TypeError, match=msg):
+        # GH#36148 require tzawareness compat as of 2.0
+        ts[naive : datetime(1990, 1, 1, 7)]
+
+    result = ts.copy()
+    with pytest.raises(TypeError, match=msg):
+        # GH#36148 require tzawareness compat as of 2.0
+        result[naive : datetime(1990, 1, 1, 7)] = 0
+    with pytest.raises(TypeError, match=msg):
+        # GH#36148 require tzawareness compat as of 2.0
+        result[naive : datetime(1990, 1, 1, 7)] = 99
+    # the __setitems__ here failed, so result should still match ts
+    tm.assert_series_equal(result, ts)
+
+    lb = naive
+    rb = datetime(1990, 1, 1, 7)
+    msg = r"Invalid comparison between dtype=datetime64\[ns, US/Eastern\] and datetime"
+    with pytest.raises(TypeError, match=msg):
+        # tznaive vs tzaware comparison is invalid
+        # see GH#18376, GH#18162
+        ts[(ts.index >= lb) & (ts.index <= rb)]
+
+    lb = Timestamp(naive).tz_localize(rng.tzinfo)
+    rb = Timestamp(datetime(1990, 1, 1, 7)).tz_localize(rng.tzinfo)
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts[ts.index[4]]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts[ts.index[4:8]]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result[ts.index[4:8]] = 0
+    result.iloc[4:8] = ts.iloc[4:8]
+    tm.assert_series_equal(result, ts)
+
+    # also test partial date slicing
+    result = ts["1990-01-02"]
+    expected = ts[24:48]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result["1990-01-02"] = 0
+    result["1990-01-02"] = ts[24:48]
+    tm.assert_series_equal(result, ts)
+
+
+def test_getitem_setitem_periodindex():
+    N = 50
+    rng = period_range("1/1/1990", periods=N, freq="H")
+    ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+
+    result = ts["1990-01-01 04"]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts.copy()
+    result["1990-01-01 04"] = 0
+    result["1990-01-01 04"] = ts.iloc[4]
+    tm.assert_series_equal(result, ts)
+
+    result = ts["1990-01-01 04":"1990-01-01 07"]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result["1990-01-01 04":"1990-01-01 07"] = 0
+    result["1990-01-01 04":"1990-01-01 07"] = ts[4:8]
+    tm.assert_series_equal(result, ts)
+
+    lb = "1990-01-01 04"
+    rb = "1990-01-01 07"
+    result = ts[(ts.index >= lb) & (ts.index <= rb)]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    # GH 2782
+    result = ts[ts.index[4]]
+    expected = ts.iloc[4]
+    assert result == expected
+
+    result = ts[ts.index[4:8]]
+    expected = ts[4:8]
+    tm.assert_series_equal(result, expected)
+
+    result = ts.copy()
+    result[ts.index[4:8]] = 0
+    result.iloc[4:8] = ts.iloc[4:8]
+    tm.assert_series_equal(result, ts)
+
+
+def test_datetime_indexing():
+    index = date_range("1/1/2000", "1/7/2000")
+    index = index.repeat(3)
+
+    s = Series(len(index), index=index)
+    stamp = Timestamp("1/8/2000")
+
+    with pytest.raises(KeyError, match=re.escape(repr(stamp))):
+        s[stamp]
+    s[stamp] = 0
+    assert s[stamp] == 0
+
+    # not monotonic
+    s = Series(len(index), index=index)
+    s = s[::-1]
+
+    with pytest.raises(KeyError, match=re.escape(repr(stamp))):
+        s[stamp]
+    s[stamp] = 0
+    assert s[stamp] == 0
+
+
+# test duplicates in time series
+
+
+def test_indexing_with_duplicate_datetimeindex(
+    rand_series_with_duplicate_datetimeindex,
+):
+    ts = rand_series_with_duplicate_datetimeindex
+
+    uniques = ts.index.unique()
+    for date in uniques:
+        result = ts[date]
+
+        mask = ts.index == date
+        total = (ts.index == date).sum()
+        expected = ts[mask]
+        if total > 1:
+            tm.assert_series_equal(result, expected)
+        else:
+            tm.assert_almost_equal(result, expected.iloc[0])
+
+        cp = ts.copy()
+        cp[date] = 0
+        expected = Series(np.where(mask, 0, ts), index=ts.index)
+        tm.assert_series_equal(cp, expected)
+
+    key = datetime(2000, 1, 6)
+    with pytest.raises(KeyError, match=re.escape(repr(key))):
+        ts[key]
+
+    # new index
+    ts[datetime(2000, 1, 6)] = 0
+    assert ts[datetime(2000, 1, 6)] == 0
+
+
+def test_loc_getitem_over_size_cutoff(monkeypatch):
+    # #1821
+
+    monkeypatch.setattr(libindex, "_SIZE_CUTOFF", 1000)
+
+    # create large list of non periodic datetime
+    dates = []
+    sec = timedelta(seconds=1)
+    half_sec = timedelta(microseconds=500000)
+    d = datetime(2011, 12, 5, 20, 30)
+    n = 1100
+    for i in range(n):
+        dates.append(d)
+        dates.append(d + sec)
+        dates.append(d + sec + half_sec)
+        dates.append(d + sec + sec + half_sec)
+        d += 3 * sec
+
+    # duplicate some values in the list
+    duplicate_positions = np.random.default_rng(2).integers(0, len(dates) - 1, 20)
+    for p in duplicate_positions:
+        dates[p + 1] = dates[p]
+
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((len(dates), 4)),
+        index=dates,
+        columns=list("ABCD"),
+    )
+
+    pos = n * 3
+    timestamp = df.index[pos]
+    assert timestamp in df.index
+
+    # it works!
+    df.loc[timestamp]
+    assert len(df.loc[[timestamp]]) > 0
+
+
+def test_indexing_over_size_cutoff_period_index(monkeypatch):
+    # GH 27136
+
+    monkeypatch.setattr(libindex, "_SIZE_CUTOFF", 1000)
+
+    n = 1100
+    idx = period_range("1/1/2000", freq="T", periods=n)
+    assert idx._engine.over_size_threshold
+
+    s = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
+
+    pos = n - 1
+    timestamp = idx[pos]
+    assert timestamp in s.index
+
+    # it works!
+    s[timestamp]
+    assert len(s.loc[[timestamp]]) > 0
+
+
+def test_indexing_unordered():
+    # GH 2437
+    rng = date_range(start="2011-01-01", end="2011-01-15")
+    ts = Series(np.random.default_rng(2).random(len(rng)), index=rng)
+    ts2 = pd.concat([ts[0:4], ts[-4:], ts[4:-4]])
+
+    for t in ts.index:
+        expected = ts[t]
+        result = ts2[t]
+        assert expected == result
+
+    # GH 3448 (ranges)
+    def compare(slobj):
+        result = ts2[slobj].copy()
+        result = result.sort_index()
+        expected = ts[slobj]
+        expected.index = expected.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+
+    for key in [
+        slice("2011-01-01", "2011-01-15"),
+        slice("2010-12-30", "2011-01-15"),
+        slice("2011-01-01", "2011-01-16"),
+        # partial ranges
+        slice("2011-01-01", "2011-01-6"),
+        slice("2011-01-06", "2011-01-8"),
+        slice("2011-01-06", "2011-01-12"),
+    ]:
+        with pytest.raises(
+            KeyError, match="Value based partial slicing on non-monotonic"
+        ):
+            compare(key)
+
+    # single values
+    result = ts2["2011"].sort_index()
+    expected = ts["2011"]
+    expected.index = expected.index._with_freq(None)
+    tm.assert_series_equal(result, expected)
+
+
+def test_indexing_unordered2():
+    # diff freq
+    rng = date_range(datetime(2005, 1, 1), periods=20, freq="M")
+    ts = Series(np.arange(len(rng)), index=rng)
+    ts = ts.take(np.random.default_rng(2).permutation(20))
+
+    result = ts["2005"]
+    for t in result.index:
+        assert t.year == 2005
+
+
+def test_indexing():
+    idx = date_range("2001-1-1", periods=20, freq="M")
+    ts = Series(np.random.default_rng(2).random(len(idx)), index=idx)
+
+    # getting
+
+    # GH 3070, make sure semantics work on Series/Frame
+    expected = ts["2001"]
+    expected.name = "A"
+
+    df = DataFrame({"A": ts})
+
+    # GH#36179 pre-2.0 df["2001"] operated as slicing on rows. in 2.0 it behaves
+    #  like any other key, so raises
+    with pytest.raises(KeyError, match="2001"):
+        df["2001"]
+
+    # setting
+    ts["2001"] = 1
+    expected = ts["2001"]
+    expected.name = "A"
+
+    df.loc["2001", "A"] = 1
+
+    with pytest.raises(KeyError, match="2001"):
+        df["2001"]
+
+
+def test_getitem_str_month_with_datetimeindex():
+    # GH3546 (not including times on the last day)
+    idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:00", freq="H")
+    ts = Series(range(len(idx)), index=idx)
+    expected = ts["2013-05"]
+    tm.assert_series_equal(expected, ts)
+
+    idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:59", freq="S")
+    ts = Series(range(len(idx)), index=idx)
+    expected = ts["2013-05"]
+    tm.assert_series_equal(expected, ts)
+
+
+def test_getitem_str_year_with_datetimeindex():
+    idx = [
+        Timestamp("2013-05-31 00:00"),
+        Timestamp(datetime(2013, 5, 31, 23, 59, 59, 999999)),
+    ]
+    ts = Series(range(len(idx)), index=idx)
+    expected = ts["2013"]
+    tm.assert_series_equal(expected, ts)
+
+
+def test_getitem_str_second_with_datetimeindex():
+    # GH14826, indexing with a seconds resolution string / datetime object
+    df = DataFrame(
+        np.random.default_rng(2).random((5, 5)),
+        columns=["open", "high", "low", "close", "volume"],
+        index=date_range("2012-01-02 18:01:00", periods=5, tz="US/Central", freq="s"),
+    )
+
+    # this is a single date, so will raise
+    with pytest.raises(KeyError, match=r"^'2012-01-02 18:01:02'$"):
+        df["2012-01-02 18:01:02"]
+
+    msg = r"Timestamp\('2012-01-02 18:01:02-0600', tz='US/Central'\)"
+    with pytest.raises(KeyError, match=msg):
+        df[df.index[2]]
+
+
+def test_compare_datetime_with_all_none():
+    # GH#54870
+    ser = Series(["2020-01-01", "2020-01-02"], dtype="datetime64[ns]")
+    ser2 = Series([None, None])
+    result = ser > ser2
+    expected = Series([False, False])
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_delitem.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_delitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..af6b3910baec036424ad84e796e4e03952524421
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_delitem.py
@@ -0,0 +1,73 @@
+import pytest
+
+from pandas import (
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesDelItem:
+    def test_delitem(self):
+        # GH#5542
+        # should delete the item inplace
+        s = Series(range(5))
+        del s[0]
+
+        expected = Series(range(1, 5), index=range(1, 5))
+        tm.assert_series_equal(s, expected)
+
+        del s[1]
+        expected = Series(range(2, 5), index=range(2, 5))
+        tm.assert_series_equal(s, expected)
+
+        # only 1 left, del, add, del
+        s = Series(1)
+        del s[0]
+        tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
+        s[0] = 1
+        tm.assert_series_equal(s, Series(1))
+        del s[0]
+        tm.assert_series_equal(s, Series(dtype="int64", index=Index([], dtype="int64")))
+
+    def test_delitem_object_index(self):
+        # Index(dtype=object)
+        s = Series(1, index=["a"])
+        del s["a"]
+        tm.assert_series_equal(
+            s, Series(dtype="int64", index=Index([], dtype="object"))
+        )
+        s["a"] = 1
+        tm.assert_series_equal(s, Series(1, index=["a"]))
+        del s["a"]
+        tm.assert_series_equal(
+            s, Series(dtype="int64", index=Index([], dtype="object"))
+        )
+
+    def test_delitem_missing_key(self):
+        # empty
+        s = Series(dtype=object)
+
+        with pytest.raises(KeyError, match=r"^0$"):
+            del s[0]
+
+    def test_delitem_extension_dtype(self):
+        # GH#40386
+        # DatetimeTZDtype
+        dti = date_range("2016-01-01", periods=3, tz="US/Pacific")
+        ser = Series(dti)
+
+        expected = ser[[0, 2]]
+        del ser[1]
+        assert ser.dtype == dti.dtype
+        tm.assert_series_equal(ser, expected)
+
+        # PeriodDtype
+        pi = dti.tz_localize(None).to_period("D")
+        ser = Series(pi)
+
+        expected = ser[:2]
+        del ser[2]
+        assert ser.dtype == pi.dtype
+        tm.assert_series_equal(ser, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_get.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_get.py
new file mode 100644
index 0000000000000000000000000000000000000000..61007c08b50e084a4250edaaaac6bfdd1221d620
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_get.py
@@ -0,0 +1,234 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_get():
+    # GH 6383
+    s = Series(
+        np.array(
+            [
+                43,
+                48,
+                60,
+                48,
+                50,
+                51,
+                50,
+                45,
+                57,
+                48,
+                56,
+                45,
+                51,
+                39,
+                55,
+                43,
+                54,
+                52,
+                51,
+                54,
+            ]
+        )
+    )
+
+    result = s.get(25, 0)
+    expected = 0
+    assert result == expected
+
+    s = Series(
+        np.array(
+            [
+                43,
+                48,
+                60,
+                48,
+                50,
+                51,
+                50,
+                45,
+                57,
+                48,
+                56,
+                45,
+                51,
+                39,
+                55,
+                43,
+                54,
+                52,
+                51,
+                54,
+            ]
+        ),
+        index=Index(
+            [
+                25.0,
+                36.0,
+                49.0,
+                64.0,
+                81.0,
+                100.0,
+                121.0,
+                144.0,
+                169.0,
+                196.0,
+                1225.0,
+                1296.0,
+                1369.0,
+                1444.0,
+                1521.0,
+                1600.0,
+                1681.0,
+                1764.0,
+                1849.0,
+                1936.0,
+            ],
+            dtype=np.float64,
+        ),
+    )
+
+    result = s.get(25, 0)
+    expected = 43
+    assert result == expected
+
+    # GH 7407
+    # with a boolean accessor
+    df = pd.DataFrame({"i": [0] * 3, "b": [False] * 3})
+    vc = df.i.value_counts()
+    result = vc.get(99, default="Missing")
+    assert result == "Missing"
+
+    vc = df.b.value_counts()
+    result = vc.get(False, default="Missing")
+    assert result == 3
+
+    result = vc.get(True, default="Missing")
+    assert result == "Missing"
+
+
+def test_get_nan(float_numpy_dtype):
+    # GH 8569
+    s = Index(range(10), dtype=float_numpy_dtype).to_series()
+    assert s.get(np.nan) is None
+    assert s.get(np.nan, default="Missing") == "Missing"
+
+
+def test_get_nan_multiple(float_numpy_dtype):
+    # GH 8569
+    # ensure that fixing "test_get_nan" above hasn't broken get
+    # with multiple elements
+    s = Index(range(10), dtype=float_numpy_dtype).to_series()
+
+    idx = [2, 30]
+    assert s.get(idx) is None
+
+    idx = [2, np.nan]
+    assert s.get(idx) is None
+
+    # GH 17295 - all missing keys
+    idx = [20, 30]
+    assert s.get(idx) is None
+
+    idx = [np.nan, np.nan]
+    assert s.get(idx) is None
+
+
+def test_get_with_default():
+    # GH#7725
+    d0 = ["a", "b", "c", "d"]
+    d1 = np.arange(4, dtype="int64")
+
+    for data, index in ((d0, d1), (d1, d0)):
+        s = Series(data, index=index)
+        for i, d in zip(index, data):
+            assert s.get(i) == d
+            assert s.get(i, d) == d
+            assert s.get(i, "z") == d
+
+            assert s.get("e", "z") == "z"
+            assert s.get("e", "e") == "e"
+
+            msg = "Series.__getitem__ treating keys as positions is deprecated"
+            warn = None
+            if index is d0:
+                warn = FutureWarning
+            with tm.assert_produces_warning(warn, match=msg):
+                assert s.get(10, "z") == "z"
+                assert s.get(10, 10) == 10
+
+
+@pytest.mark.parametrize(
+    "arr",
+    [
+        np.random.default_rng(2).standard_normal(10),
+        tm.makeDateIndex(10, name="a").tz_localize(tz="US/Eastern"),
+    ],
+)
+def test_get_with_ea(arr):
+    # GH#21260
+    ser = Series(arr, index=[2 * i for i in range(len(arr))])
+    assert ser.get(4) == ser.iloc[2]
+
+    result = ser.get([4, 6])
+    expected = ser.iloc[[2, 3]]
+    tm.assert_series_equal(result, expected)
+
+    result = ser.get(slice(2))
+    expected = ser.iloc[[0, 1]]
+    tm.assert_series_equal(result, expected)
+
+    assert ser.get(-1) is None
+    assert ser.get(ser.index.max() + 1) is None
+
+    ser = Series(arr[:6], index=list("abcdef"))
+    assert ser.get("c") == ser.iloc[2]
+
+    result = ser.get(slice("b", "d"))
+    expected = ser.iloc[[1, 2, 3]]
+    tm.assert_series_equal(result, expected)
+
+    result = ser.get("Z")
+    assert result is None
+
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert ser.get(4) == ser.iloc[4]
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert ser.get(-1) == ser.iloc[-1]
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert ser.get(len(ser)) is None
+
+    # GH#21257
+    ser = Series(arr)
+    ser2 = ser[::2]
+    assert ser2.get(1) is None
+
+
+def test_getitem_get(string_series, object_series):
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+
+    for obj in [string_series, object_series]:
+        idx = obj.index[5]
+
+        assert obj[idx] == obj.get(idx)
+        assert obj[idx] == obj.iloc[5]
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert string_series.get(-1) == string_series.get(string_series.index[-1])
+    assert string_series.iloc[5] == string_series.get(string_series.index[5])
+
+
+def test_get_none():
+    # GH#5652
+    s1 = Series(dtype=object)
+    s2 = Series(dtype=object, index=list("abc"))
+    for s in [s1, s2]:
+        result = s.get(None)
+        assert result is None
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_getitem.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_getitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..458988491aae807903d9e1e65d02b46e5c415d44
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_getitem.py
@@ -0,0 +1,733 @@
+"""
+Series.__getitem__ test classes are organized by the type of key passed.
+"""
+from datetime import (
+    date,
+    datetime,
+    time,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    conversion,
+    timezones,
+)
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core.indexing import IndexingError
+
+from pandas.tseries.offsets import BDay
+
+
+class TestSeriesGetitemScalars:
+    def test_getitem_object_index_float_string(self):
+        # GH#17286
+        ser = Series([1] * 4, index=Index(["a", "b", "c", 1.0]))
+        assert ser["a"] == 1
+        assert ser[1.0] == 1
+
+    def test_getitem_float_keys_tuple_values(self):
+        # see GH#13509
+
+        # unique Index
+        ser = Series([(1, 1), (2, 2), (3, 3)], index=[0.0, 0.1, 0.2], name="foo")
+        result = ser[0.0]
+        assert result == (1, 1)
+
+        # non-unique Index
+        expected = Series([(1, 1), (2, 2)], index=[0.0, 0.0], name="foo")
+        ser = Series([(1, 1), (2, 2), (3, 3)], index=[0.0, 0.0, 0.2], name="foo")
+
+        result = ser[0.0]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_unrecognized_scalar(self):
+        # GH#32684 a scalar key that is not recognized by lib.is_scalar
+
+        # a series that might be produced via `frame.dtypes`
+        ser = Series([1, 2], index=[np.dtype("O"), np.dtype("i8")])
+
+        key = ser.index[1]
+
+        result = ser[key]
+        assert result == 2
+
+    def test_getitem_negative_out_of_bounds(self):
+        ser = Series(["a"] * 10, index=["a"] * 10)
+
+        msg = "index -11 is out of bounds for axis 0 with size 10"
+        warn_msg = "Series.__getitem__ treating keys as positions is deprecated"
+        with pytest.raises(IndexError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                ser[-11]
+
+    def test_getitem_out_of_bounds_indexerror(self, datetime_series):
+        # don't segfault, GH#495
+        msg = r"index \d+ is out of bounds for axis 0 with size \d+"
+        warn_msg = "Series.__getitem__ treating keys as positions is deprecated"
+        with pytest.raises(IndexError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                datetime_series[len(datetime_series)]
+
+    def test_getitem_out_of_bounds_empty_rangeindex_keyerror(self):
+        # GH#917
+        # With a RangeIndex, an int key gives a KeyError
+        ser = Series([], dtype=object)
+        with pytest.raises(KeyError, match="-1"):
+            ser[-1]
+
+    def test_getitem_keyerror_with_integer_index(self, any_int_numpy_dtype):
+        dtype = any_int_numpy_dtype
+        ser = Series(
+            np.random.default_rng(2).standard_normal(6),
+            index=Index([0, 0, 1, 1, 2, 2], dtype=dtype),
+        )
+
+        with pytest.raises(KeyError, match=r"^5$"):
+            ser[5]
+
+        with pytest.raises(KeyError, match=r"^'c'$"):
+            ser["c"]
+
+        # not monotonic
+        ser = Series(
+            np.random.default_rng(2).standard_normal(6), index=[2, 2, 0, 0, 1, 1]
+        )
+
+        with pytest.raises(KeyError, match=r"^5$"):
+            ser[5]
+
+        with pytest.raises(KeyError, match=r"^'c'$"):
+            ser["c"]
+
+    def test_getitem_int64(self, datetime_series):
+        idx = np.int64(5)
+        msg = "Series.__getitem__ treating keys as positions is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = datetime_series[idx]
+        assert res == datetime_series.iloc[5]
+
+    def test_getitem_full_range(self):
+        # github.com/pandas-dev/pandas/commit/4f433773141d2eb384325714a2776bcc5b2e20f7
+        ser = Series(range(5), index=list(range(5)))
+        result = ser[list(range(5))]
+        tm.assert_series_equal(result, ser)
+
+    # ------------------------------------------------------------------
+    # Series with DatetimeIndex
+
+    @pytest.mark.parametrize("tzstr", ["Europe/Berlin", "dateutil/Europe/Berlin"])
+    def test_getitem_pydatetime_tz(self, tzstr):
+        tz = timezones.maybe_get_tz(tzstr)
+
+        index = date_range(
+            start="2012-12-24 16:00", end="2012-12-24 18:00", freq="H", tz=tzstr
+        )
+        ts = Series(index=index, data=index.hour)
+        time_pandas = Timestamp("2012-12-24 17:00", tz=tzstr)
+
+        dt = datetime(2012, 12, 24, 17, 0)
+        time_datetime = conversion.localize_pydatetime(dt, tz)
+        assert ts[time_pandas] == ts[time_datetime]
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_string_index_alias_tz_aware(self, tz):
+        rng = date_range("1/1/2000", periods=10, tz=tz)
+        ser = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        result = ser["1/3/2000"]
+        tm.assert_almost_equal(result, ser.iloc[2])
+
+    def test_getitem_time_object(self):
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        mask = (rng.hour == 9) & (rng.minute == 30)
+        result = ts[time(9, 30)]
+        expected = ts[mask]
+        result.index = result.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+
+    # ------------------------------------------------------------------
+    # Series with CategoricalIndex
+
+    def test_getitem_scalar_categorical_index(self):
+        cats = Categorical([Timestamp("12-31-1999"), Timestamp("12-31-2000")])
+
+        ser = Series([1, 2], index=cats)
+
+        expected = ser.iloc[0]
+        result = ser[cats[0]]
+        assert result == expected
+
+    def test_getitem_numeric_categorical_listlike_matches_scalar(self):
+        # GH#15470
+        ser = Series(["a", "b", "c"], index=pd.CategoricalIndex([2, 1, 0]))
+
+        # 0 is treated as a label
+        assert ser[0] == "c"
+
+        # the listlike analogue should also be treated as labels
+        res = ser[[0]]
+        expected = ser.iloc[-1:]
+        tm.assert_series_equal(res, expected)
+
+        res2 = ser[[0, 1, 2]]
+        tm.assert_series_equal(res2, ser.iloc[::-1])
+
+    def test_getitem_integer_categorical_not_positional(self):
+        # GH#14865
+        ser = Series(["a", "b", "c"], index=Index([1, 2, 3], dtype="category"))
+        assert ser.get(3) == "c"
+        assert ser[3] == "c"
+
+    def test_getitem_str_with_timedeltaindex(self):
+        rng = timedelta_range("1 day 10:11:12", freq="h", periods=500)
+        ser = Series(np.arange(len(rng)), index=rng)
+
+        key = "6 days, 23:11:12"
+        indexer = rng.get_loc(key)
+        assert indexer == 133
+
+        result = ser[key]
+        assert result == ser.iloc[133]
+
+        msg = r"^Timedelta\('50 days 00:00:00'\)$"
+        with pytest.raises(KeyError, match=msg):
+            rng.get_loc("50 days")
+        with pytest.raises(KeyError, match=msg):
+            ser["50 days"]
+
+    def test_getitem_bool_index_positional(self):
+        # GH#48653
+        ser = Series({True: 1, False: 0})
+        msg = "Series.__getitem__ treating keys as positions is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser[0]
+        assert result == 1
+
+
+class TestSeriesGetitemSlices:
+    def test_getitem_partial_str_slice_with_datetimeindex(self):
+        # GH#34860
+        arr = date_range("1/1/2008", "1/1/2009")
+        ser = arr.to_series()
+        result = ser["2008"]
+
+        rng = date_range(start="2008-01-01", end="2008-12-31")
+        expected = Series(rng, index=rng)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_slice_strings_with_datetimeindex(self):
+        idx = DatetimeIndex(
+            ["1/1/2000", "1/2/2000", "1/2/2000", "1/3/2000", "1/4/2000"]
+        )
+
+        ts = Series(np.random.default_rng(2).standard_normal(len(idx)), index=idx)
+
+        result = ts["1/2/2000":]
+        expected = ts[1:]
+        tm.assert_series_equal(result, expected)
+
+        result = ts["1/2/2000":"1/3/2000"]
+        expected = ts[1:4]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_partial_str_slice_with_timedeltaindex(self):
+        rng = timedelta_range("1 day 10:11:12", freq="h", periods=500)
+        ser = Series(np.arange(len(rng)), index=rng)
+
+        result = ser["5 day":"6 day"]
+        expected = ser.iloc[86:134]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["5 day":]
+        expected = ser.iloc[86:]
+        tm.assert_series_equal(result, expected)
+
+        result = ser[:"6 day"]
+        expected = ser.iloc[:134]
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_partial_str_slice_high_reso_with_timedeltaindex(self):
+        # higher reso
+        rng = timedelta_range("1 day 10:11:12", freq="us", periods=2000)
+        ser = Series(np.arange(len(rng)), index=rng)
+
+        result = ser["1 day 10:11:12":]
+        expected = ser.iloc[0:]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["1 day 10:11:12.001":]
+        expected = ser.iloc[1000:]
+        tm.assert_series_equal(result, expected)
+
+        result = ser["1 days, 10:11:12.001001"]
+        assert result == ser.iloc[1001]
+
+    def test_getitem_slice_2d(self, datetime_series):
+        # GH#30588 multi-dimensional indexing deprecated
+        with pytest.raises(ValueError, match="Multi-dimensional indexing"):
+            datetime_series[:, np.newaxis]
+
+    def test_getitem_median_slice_bug(self):
+        index = date_range("20090415", "20090519", freq="2B")
+        ser = Series(np.random.default_rng(2).standard_normal(13), index=index)
+
+        indexer = [slice(6, 7, None)]
+        msg = "Indexing with a single-item list"
+        with pytest.raises(ValueError, match=msg):
+            # GH#31299
+            ser[indexer]
+        # but we're OK with a single-element tuple
+        result = ser[(indexer[0],)]
+        expected = ser[indexer[0]]
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "slc, positions",
+        [
+            [slice(date(2018, 1, 1), None), [0, 1, 2]],
+            [slice(date(2019, 1, 2), None), [2]],
+            [slice(date(2020, 1, 1), None), []],
+            [slice(None, date(2020, 1, 1)), [0, 1, 2]],
+            [slice(None, date(2019, 1, 1)), [0]],
+        ],
+    )
+    def test_getitem_slice_date(self, slc, positions):
+        # https://github.com/pandas-dev/pandas/issues/31501
+        ser = Series(
+            [0, 1, 2],
+            DatetimeIndex(["2019-01-01", "2019-01-01T06:00:00", "2019-01-02"]),
+        )
+        result = ser[slc]
+        expected = ser.take(positions)
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_slice_float_raises(self, datetime_series):
+        msg = (
+            "cannot do slice indexing on DatetimeIndex with these indexers "
+            r"\[{key}\] of type float"
+        )
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
+            datetime_series[4.0:10.0]
+
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
+            datetime_series[4.5:10.0]
+
+    def test_getitem_slice_bug(self):
+        ser = Series(range(10), index=list(range(10)))
+        result = ser[-12:]
+        tm.assert_series_equal(result, ser)
+
+        result = ser[-7:]
+        tm.assert_series_equal(result, ser[3:])
+
+        result = ser[:-12]
+        tm.assert_series_equal(result, ser[:0])
+
+    def test_getitem_slice_integers(self):
+        ser = Series(
+            np.random.default_rng(2).standard_normal(8),
+            index=[2, 4, 6, 8, 10, 12, 14, 16],
+        )
+
+        result = ser[:4]
+        expected = Series(ser.values[:4], index=[2, 4, 6, 8])
+        tm.assert_series_equal(result, expected)
+
+
+class TestSeriesGetitemListLike:
+    @pytest.mark.parametrize("box", [list, np.array, Index, Series])
+    def test_getitem_no_matches(self, box):
+        # GH#33462 we expect the same behavior for list/ndarray/Index/Series
+        ser = Series(["A", "B"])
+
+        key = Series(["C"], dtype=object)
+        key = box(key)
+
+        msg = r"None of \[Index\(\['C'\], dtype='object'\)\] are in the \[index\]"
+        with pytest.raises(KeyError, match=msg):
+            ser[key]
+
+    def test_getitem_intlist_intindex_periodvalues(self):
+        ser = Series(period_range("2000-01-01", periods=10, freq="D"))
+
+        result = ser[[2, 4]]
+        exp = Series(
+            [pd.Period("2000-01-03", freq="D"), pd.Period("2000-01-05", freq="D")],
+            index=[2, 4],
+            dtype="Period[D]",
+        )
+        tm.assert_series_equal(result, exp)
+        assert result.dtype == "Period[D]"
+
+    @pytest.mark.parametrize("box", [list, np.array, Index])
+    def test_getitem_intlist_intervalindex_non_int(self, box):
+        # GH#33404 fall back to positional since ints are unambiguous
+        dti = date_range("2000-01-03", periods=3)._with_freq(None)
+        ii = pd.IntervalIndex.from_breaks(dti)
+        ser = Series(range(len(ii)), index=ii)
+
+        expected = ser.iloc[:1]
+        key = box([0])
+        msg = "Series.__getitem__ treating keys as positions is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser[key]
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("box", [list, np.array, Index])
+    @pytest.mark.parametrize("dtype", [np.int64, np.float64, np.uint64])
+    def test_getitem_intlist_multiindex_numeric_level(self, dtype, box):
+        # GH#33404 do _not_ fall back to positional since ints are ambiguous
+        idx = Index(range(4)).astype(dtype)
+        dti = date_range("2000-01-03", periods=3)
+        mi = pd.MultiIndex.from_product([idx, dti])
+        ser = Series(range(len(mi))[::-1], index=mi)
+
+        key = box([5])
+        with pytest.raises(KeyError, match="5"):
+            ser[key]
+
+    def test_getitem_uint_array_key(self, any_unsigned_int_numpy_dtype):
+        # GH #37218
+        ser = Series([1, 2, 3])
+        key = np.array([4], dtype=any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(KeyError, match="4"):
+            ser[key]
+        with pytest.raises(KeyError, match="4"):
+            ser.loc[key]
+
+
+class TestGetitemBooleanMask:
+    def test_getitem_boolean(self, string_series):
+        ser = string_series
+        mask = ser > ser.median()
+
+        # passing list is OK
+        result = ser[list(mask)]
+        expected = ser[mask]
+        tm.assert_series_equal(result, expected)
+        tm.assert_index_equal(result.index, ser.index[mask])
+
+    def test_getitem_boolean_empty(self):
+        ser = Series([], dtype=np.int64)
+        ser.index.name = "index_name"
+        ser = ser[ser.isna()]
+        assert ser.index.name == "index_name"
+        assert ser.dtype == np.int64
+
+        # GH#5877
+        # indexing with empty series
+        ser = Series(["A", "B"])
+        expected = Series(dtype=object, index=Index([], dtype="int64"))
+        result = ser[Series([], dtype=object)]
+        tm.assert_series_equal(result, expected)
+
+        # invalid because of the boolean indexer
+        # that's empty or not-aligned
+        msg = (
+            r"Unalignable boolean Series provided as indexer \(index of "
+            r"the boolean Series and of the indexed object do not match"
+        )
+        with pytest.raises(IndexingError, match=msg):
+            ser[Series([], dtype=bool)]
+
+        with pytest.raises(IndexingError, match=msg):
+            ser[Series([True], dtype=bool)]
+
+    def test_getitem_boolean_object(self, string_series):
+        # using column from DataFrame
+
+        ser = string_series
+        mask = ser > ser.median()
+        omask = mask.astype(object)
+
+        # getitem
+        result = ser[omask]
+        expected = ser[mask]
+        tm.assert_series_equal(result, expected)
+
+        # setitem
+        s2 = ser.copy()
+        cop = ser.copy()
+        cop[omask] = 5
+        s2[mask] = 5
+        tm.assert_series_equal(cop, s2)
+
+        # nans raise exception
+        omask[5:10] = np.nan
+        msg = "Cannot mask with non-boolean array containing NA / NaN values"
+        with pytest.raises(ValueError, match=msg):
+            ser[omask]
+        with pytest.raises(ValueError, match=msg):
+            ser[omask] = 5
+
+    def test_getitem_boolean_dt64_copies(self):
+        # GH#36210
+        dti = date_range("2016-01-01", periods=4, tz="US/Pacific")
+        key = np.array([True, True, False, False])
+
+        ser = Series(dti._data)
+
+        res = ser[key]
+        assert res._values._ndarray.base is None
+
+        # compare with numeric case for reference
+        ser2 = Series(range(4))
+        res2 = ser2[key]
+        assert res2._values.base is None
+
+    def test_getitem_boolean_corner(self, datetime_series):
+        ts = datetime_series
+        mask_shifted = ts.shift(1, freq=BDay()) > ts.median()
+
+        msg = (
+            r"Unalignable boolean Series provided as indexer \(index of "
+            r"the boolean Series and of the indexed object do not match"
+        )
+        with pytest.raises(IndexingError, match=msg):
+            ts[mask_shifted]
+
+        with pytest.raises(IndexingError, match=msg):
+            ts.loc[mask_shifted]
+
+    def test_getitem_boolean_different_order(self, string_series):
+        ordered = string_series.sort_values()
+
+        sel = string_series[ordered > 0]
+        exp = string_series[string_series > 0]
+        tm.assert_series_equal(sel, exp)
+
+    def test_getitem_boolean_contiguous_preserve_freq(self):
+        rng = date_range("1/1/2000", "3/1/2000", freq="B")
+
+        mask = np.zeros(len(rng), dtype=bool)
+        mask[10:20] = True
+
+        masked = rng[mask]
+        expected = rng[10:20]
+        assert expected.freq == rng.freq
+        tm.assert_index_equal(masked, expected)
+
+        mask[22] = True
+        masked = rng[mask]
+        assert masked.freq is None
+
+
+class TestGetitemCallable:
+    def test_getitem_callable(self):
+        # GH#12533
+        ser = Series(4, index=list("ABCD"))
+        result = ser[lambda x: "A"]
+        assert result == ser.loc["A"]
+
+        result = ser[lambda x: ["A", "B"]]
+        expected = ser.loc[["A", "B"]]
+        tm.assert_series_equal(result, expected)
+
+        result = ser[lambda x: [True, False, True, True]]
+        expected = ser.iloc[[0, 2, 3]]
+        tm.assert_series_equal(result, expected)
+
+
+def test_getitem_generator(string_series):
+    gen = (x > 0 for x in string_series)
+    result = string_series[gen]
+    result2 = string_series[iter(string_series > 0)]
+    expected = string_series[string_series > 0]
+    tm.assert_series_equal(result, expected)
+    tm.assert_series_equal(result2, expected)
+
+
+@pytest.mark.parametrize(
+    "series",
+    [
+        Series([0, 1]),
+        Series(date_range("2012-01-01", periods=2)),
+        Series(date_range("2012-01-01", periods=2, tz="CET")),
+    ],
+)
+def test_getitem_ndim_deprecated(series):
+    with pytest.raises(ValueError, match="Multi-dimensional indexing"):
+        series[:, None]
+
+
+def test_getitem_multilevel_scalar_slice_not_implemented(
+    multiindex_year_month_day_dataframe_random_data,
+):
+    # not implementing this for now
+    df = multiindex_year_month_day_dataframe_random_data
+    ser = df["A"]
+
+    msg = r"\(2000, slice\(3, 4, None\)\)"
+    with pytest.raises(TypeError, match=msg):
+        ser[2000, 3:4]
+
+
+def test_getitem_dataframe_raises():
+    rng = list(range(10))
+    ser = Series(10, index=rng)
+    df = DataFrame(rng, index=rng)
+    msg = (
+        "Indexing a Series with DataFrame is not supported, "
+        "use the appropriate DataFrame column"
+    )
+    with pytest.raises(TypeError, match=msg):
+        ser[df > 5]
+
+
+def test_getitem_assignment_series_alignment():
+    # https://github.com/pandas-dev/pandas/issues/37427
+    # with getitem, when assigning with a Series, it is not first aligned
+    ser = Series(range(10))
+    idx = np.array([2, 4, 9])
+    ser[idx] = Series([10, 11, 12])
+    expected = Series([0, 1, 10, 3, 11, 5, 6, 7, 8, 12])
+    tm.assert_series_equal(ser, expected)
+
+
+def test_getitem_duplicate_index_mistyped_key_raises_keyerror():
+    # GH#29189 float_index.get_loc(None) should raise KeyError, not TypeError
+    ser = Series([2, 5, 6, 8], index=[2.0, 4.0, 4.0, 5.0])
+    with pytest.raises(KeyError, match="None"):
+        ser[None]
+
+    with pytest.raises(KeyError, match="None"):
+        ser.index.get_loc(None)
+
+    with pytest.raises(KeyError, match="None"):
+        ser.index._engine.get_loc(None)
+
+
+def test_getitem_1tuple_slice_without_multiindex():
+    ser = Series(range(5))
+    key = (slice(3),)
+
+    result = ser[key]
+    expected = ser[key[0]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_preserve_name(datetime_series):
+    result = datetime_series[datetime_series > 0]
+    assert result.name == datetime_series.name
+
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = datetime_series[[0, 2, 4]]
+    assert result.name == datetime_series.name
+
+    result = datetime_series[5:10]
+    assert result.name == datetime_series.name
+
+
+def test_getitem_with_integer_labels():
+    # integer indexes, be careful
+    ser = Series(
+        np.random.default_rng(2).standard_normal(10), index=list(range(0, 20, 2))
+    )
+    inds = [0, 2, 5, 7, 8]
+    arr_inds = np.array([0, 2, 5, 7, 8])
+    with pytest.raises(KeyError, match="not in index"):
+        ser[inds]
+
+    with pytest.raises(KeyError, match="not in index"):
+        ser[arr_inds]
+
+
+def test_getitem_missing(datetime_series):
+    # missing
+    d = datetime_series.index[0] - BDay()
+    msg = r"Timestamp\('1999-12-31 00:00:00'\)"
+    with pytest.raises(KeyError, match=msg):
+        datetime_series[d]
+
+
+def test_getitem_fancy(string_series, object_series):
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        slice1 = string_series[[1, 2, 3]]
+        slice2 = object_series[[1, 2, 3]]
+    assert string_series.index[2] == slice1.index[1]
+    assert object_series.index[2] == slice2.index[1]
+    assert string_series.iloc[2] == slice1.iloc[1]
+    assert object_series.iloc[2] == slice2.iloc[1]
+
+
+def test_getitem_box_float64(datetime_series):
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        value = datetime_series[5]
+    assert isinstance(value, np.float64)
+
+
+def test_getitem_unordered_dup():
+    obj = Series(range(5), index=["c", "a", "a", "b", "b"])
+    assert is_scalar(obj["c"])
+    assert obj["c"] == 0
+
+
+def test_getitem_dups():
+    ser = Series(range(5), index=["A", "A", "B", "C", "C"], dtype=np.int64)
+    expected = Series([3, 4], index=["C", "C"], dtype=np.int64)
+    result = ser["C"]
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_categorical_str():
+    # GH#31765
+    ser = Series(range(5), index=Categorical(["a", "b", "c", "a", "b"]))
+    result = ser["a"]
+    expected = ser.iloc[[0, 3]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_slice_can_reorder_not_uniquely_indexed():
+    ser = Series(1, index=["a", "a", "b", "b", "c"])
+    ser[::-1]  # it works!
+
+
+@pytest.mark.parametrize("index_vals", ["aabcd", "aadcb"])
+def test_duplicated_index_getitem_positional_indexer(index_vals):
+    # GH 11747
+    s = Series(range(5), index=list(index_vals))
+
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = s[3]
+    assert result == 3
+
+
+class TestGetitemDeprecatedIndexers:
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_getitem_dict_and_set_deprecated(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2, 3])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser[key]
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_setitem_dict_and_set_disallowed(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2, 3])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser[key] = 1
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_indexing.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fa28920d41bd55f88fa115a3a8a7d6d534b800b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_indexing.py
@@ -0,0 +1,514 @@
+""" test get/set & misc """
+from datetime import timedelta
+import re
+
+import numpy as np
+import pytest
+
+from pandas.errors import IndexingError
+
+from pandas import (
+    NA,
+    DataFrame,
+    Index,
+    IndexSlice,
+    MultiIndex,
+    NaT,
+    Series,
+    Timedelta,
+    Timestamp,
+    concat,
+    date_range,
+    isna,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+def test_basic_indexing():
+    s = Series(
+        np.random.default_rng(2).standard_normal(5), index=["a", "b", "a", "a", "b"]
+    )
+
+    warn_msg = "Series.__[sg]etitem__ treating keys as positions is deprecated"
+    msg = "index 5 is out of bounds for axis 0 with size 5"
+    with pytest.raises(IndexError, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            s[5]
+    with pytest.raises(IndexError, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            s[5] = 0
+
+    with pytest.raises(KeyError, match=r"^'c'$"):
+        s["c"]
+
+    s = s.sort_index()
+
+    with pytest.raises(IndexError, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            s[5]
+    msg = r"index 5 is out of bounds for axis (0|1) with size 5|^5$"
+    with pytest.raises(IndexError, match=msg):
+        with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+            s[5] = 0
+
+
+def test_getitem_numeric_should_not_fallback_to_positional(any_numeric_dtype):
+    # GH51053
+    dtype = any_numeric_dtype
+    idx = Index([1, 0, 1], dtype=dtype)
+    ser = Series(range(3), index=idx)
+    result = ser[1]
+    expected = Series([0, 2], index=Index([1, 1], dtype=dtype))
+    tm.assert_series_equal(result, expected, check_exact=True)
+
+
+def test_setitem_numeric_should_not_fallback_to_positional(any_numeric_dtype):
+    # GH51053
+    dtype = any_numeric_dtype
+    idx = Index([1, 0, 1], dtype=dtype)
+    ser = Series(range(3), index=idx)
+    ser[1] = 10
+    expected = Series([10, 1, 10], index=idx)
+    tm.assert_series_equal(ser, expected, check_exact=True)
+
+
+def test_basic_getitem_with_labels(datetime_series):
+    indices = datetime_series.index[[5, 10, 15]]
+
+    result = datetime_series[indices]
+    expected = datetime_series.reindex(indices)
+    tm.assert_series_equal(result, expected)
+
+    result = datetime_series[indices[0] : indices[2]]
+    expected = datetime_series.loc[indices[0] : indices[2]]
+    tm.assert_series_equal(result, expected)
+
+
+def test_basic_getitem_dt64tz_values():
+    # GH12089
+    # with tz for values
+    ser = Series(
+        date_range("2011-01-01", periods=3, tz="US/Eastern"), index=["a", "b", "c"]
+    )
+    expected = Timestamp("2011-01-01", tz="US/Eastern")
+    result = ser.loc["a"]
+    assert result == expected
+    result = ser.iloc[0]
+    assert result == expected
+    result = ser["a"]
+    assert result == expected
+
+
+def test_getitem_setitem_ellipsis():
+    s = Series(np.random.default_rng(2).standard_normal(10))
+
+    result = s[...]
+    tm.assert_series_equal(result, s)
+
+    s[...] = 5
+    assert (result == 5).all()
+
+
+@pytest.mark.parametrize(
+    "result_1, duplicate_item, expected_1",
+    [
+        [
+            Series({1: 12, 2: [1, 2, 2, 3]}),
+            Series({1: 313}),
+            Series({1: 12}, dtype=object),
+        ],
+        [
+            Series({1: [1, 2, 3], 2: [1, 2, 2, 3]}),
+            Series({1: [1, 2, 3]}),
+            Series({1: [1, 2, 3]}),
+        ],
+    ],
+)
+def test_getitem_with_duplicates_indices(result_1, duplicate_item, expected_1):
+    # GH 17610
+    result = result_1._append(duplicate_item)
+    expected = expected_1._append(duplicate_item)
+    tm.assert_series_equal(result[1], expected)
+    assert result[2] == result_1[2]
+
+
+def test_getitem_setitem_integers():
+    # caused bug without test
+    s = Series([1, 2, 3], ["a", "b", "c"])
+
+    assert s.iloc[0] == s["a"]
+    s.iloc[0] = 5
+    tm.assert_almost_equal(s["a"], 5)
+
+
+def test_series_box_timestamp():
+    rng = date_range("20090415", "20090519", freq="B")
+    ser = Series(rng)
+    assert isinstance(ser[0], Timestamp)
+    assert isinstance(ser.at[1], Timestamp)
+    assert isinstance(ser.iat[2], Timestamp)
+    assert isinstance(ser.loc[3], Timestamp)
+    assert isinstance(ser.iloc[4], Timestamp)
+
+    ser = Series(rng, index=rng)
+    msg = "Series.__getitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert isinstance(ser[0], Timestamp)
+    assert isinstance(ser.at[rng[1]], Timestamp)
+    assert isinstance(ser.iat[2], Timestamp)
+    assert isinstance(ser.loc[rng[3]], Timestamp)
+    assert isinstance(ser.iloc[4], Timestamp)
+
+
+def test_series_box_timedelta():
+    rng = timedelta_range("1 day 1 s", periods=5, freq="h")
+    ser = Series(rng)
+    assert isinstance(ser[0], Timedelta)
+    assert isinstance(ser.at[1], Timedelta)
+    assert isinstance(ser.iat[2], Timedelta)
+    assert isinstance(ser.loc[3], Timedelta)
+    assert isinstance(ser.iloc[4], Timedelta)
+
+
+def test_getitem_ambiguous_keyerror(indexer_sl):
+    ser = Series(range(10), index=list(range(0, 20, 2)))
+    with pytest.raises(KeyError, match=r"^1$"):
+        indexer_sl(ser)[1]
+
+
+def test_getitem_dups_with_missing(indexer_sl):
+    # breaks reindex, so need to use .loc internally
+    # GH 4246
+    ser = Series([1, 2, 3, 4], ["foo", "bar", "foo", "bah"])
+    with pytest.raises(KeyError, match=re.escape("['bam'] not in index")):
+        indexer_sl(ser)[["foo", "bar", "bah", "bam"]]
+
+
+def test_setitem_ambiguous_keyerror(indexer_sl):
+    s = Series(range(10), index=list(range(0, 20, 2)))
+
+    # equivalent of an append
+    s2 = s.copy()
+    indexer_sl(s2)[1] = 5
+    expected = concat([s, Series([5], index=[1])])
+    tm.assert_series_equal(s2, expected)
+
+
+def test_setitem(datetime_series):
+    datetime_series[datetime_series.index[5]] = np.nan
+    datetime_series.iloc[[1, 2, 17]] = np.nan
+    datetime_series.iloc[6] = np.nan
+    assert np.isnan(datetime_series.iloc[6])
+    assert np.isnan(datetime_series.iloc[2])
+    datetime_series[np.isnan(datetime_series)] = 5
+    assert not np.isnan(datetime_series.iloc[2])
+
+
+def test_setslice(datetime_series):
+    sl = datetime_series[5:20]
+    assert len(sl) == len(sl.index)
+    assert sl.index.is_unique is True
+
+
+def test_basic_getitem_setitem_corner(datetime_series):
+    # invalid tuples, e.g. td.ts[:, None] vs. td.ts[:, 2]
+    msg = "key of type tuple not found and not a MultiIndex"
+    with pytest.raises(KeyError, match=msg):
+        datetime_series[:, 2]
+    with pytest.raises(KeyError, match=msg):
+        datetime_series[:, 2] = 2
+
+    # weird lists. [slice(0, 5)] raises but not two slices
+    msg = "Indexing with a single-item list"
+    with pytest.raises(ValueError, match=msg):
+        # GH#31299
+        datetime_series[[slice(None, 5)]]
+
+    # but we're OK with a single-element tuple
+    result = datetime_series[(slice(None, 5),)]
+    expected = datetime_series[:5]
+    tm.assert_series_equal(result, expected)
+
+    # OK
+    msg = r"unhashable type(: 'slice')?"
+    with pytest.raises(TypeError, match=msg):
+        datetime_series[[5, [None, None]]]
+    with pytest.raises(TypeError, match=msg):
+        datetime_series[[5, [None, None]]] = 2
+
+
+def test_slice(string_series, object_series, using_copy_on_write):
+    original = string_series.copy()
+    numSlice = string_series[10:20]
+    numSliceEnd = string_series[-10:]
+    objSlice = object_series[10:20]
+
+    assert string_series.index[9] not in numSlice.index
+    assert object_series.index[9] not in objSlice.index
+
+    assert len(numSlice) == len(numSlice.index)
+    assert string_series[numSlice.index[0]] == numSlice[numSlice.index[0]]
+
+    assert numSlice.index[1] == string_series.index[11]
+    assert tm.equalContents(numSliceEnd, np.array(string_series)[-10:])
+
+    # Test return view.
+    sl = string_series[10:20]
+    sl[:] = 0
+
+    if using_copy_on_write:
+        # Doesn't modify parent (CoW)
+        tm.assert_series_equal(string_series, original)
+    else:
+        assert (string_series[10:20] == 0).all()
+
+
+def test_timedelta_assignment():
+    # GH 8209
+    s = Series([], dtype=object)
+    s.loc["B"] = timedelta(1)
+    tm.assert_series_equal(s, Series(Timedelta("1 days"), index=["B"]))
+
+    s = s.reindex(s.index.insert(0, "A"))
+    tm.assert_series_equal(s, Series([np.nan, Timedelta("1 days")], index=["A", "B"]))
+
+    s.loc["A"] = timedelta(1)
+    expected = Series(Timedelta("1 days"), index=["A", "B"])
+    tm.assert_series_equal(s, expected)
+
+
+def test_underlying_data_conversion(using_copy_on_write):
+    # GH 4080
+    df = DataFrame({c: [1, 2, 3] for c in ["a", "b", "c"]})
+    return_value = df.set_index(["a", "b", "c"], inplace=True)
+    assert return_value is None
+    s = Series([1], index=[(2, 2, 2)])
+    df["val"] = 0
+    df_original = df.copy()
+    df
+
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["val"].update(s)
+        expected = df_original
+    else:
+        df["val"].update(s)
+        expected = DataFrame(
+            {"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3], "val": [0, 1, 0]}
+        )
+        return_value = expected.set_index(["a", "b", "c"], inplace=True)
+        assert return_value is None
+    tm.assert_frame_equal(df, expected)
+
+
+def test_preserve_refs(datetime_series):
+    seq = datetime_series.iloc[[5, 10, 15]]
+    seq.iloc[1] = np.nan
+    assert not np.isnan(datetime_series.iloc[10])
+
+
+def test_multilevel_preserve_name(lexsorted_two_level_string_multiindex, indexer_sl):
+    index = lexsorted_two_level_string_multiindex
+    ser = Series(
+        np.random.default_rng(2).standard_normal(len(index)), index=index, name="sth"
+    )
+
+    result = indexer_sl(ser)["foo"]
+    assert result.name == ser.name
+
+
+# miscellaneous methods
+
+
+@pytest.mark.parametrize(
+    "index",
+    [
+        date_range("2014-01-01", periods=20, freq="MS"),
+        period_range("2014-01", periods=20, freq="M"),
+        timedelta_range("0", periods=20, freq="H"),
+    ],
+)
+def test_slice_with_negative_step(index):
+    keystr1 = str(index[9])
+    keystr2 = str(index[13])
+
+    ser = Series(np.arange(20), index)
+    SLC = IndexSlice
+
+    for key in [keystr1, index[9]]:
+        tm.assert_indexing_slices_equivalent(ser, SLC[key::-1], SLC[9::-1])
+        tm.assert_indexing_slices_equivalent(ser, SLC[:key:-1], SLC[:8:-1])
+
+        for key2 in [keystr2, index[13]]:
+            tm.assert_indexing_slices_equivalent(ser, SLC[key2:key:-1], SLC[13:8:-1])
+            tm.assert_indexing_slices_equivalent(ser, SLC[key:key2:-1], SLC[0:0:-1])
+
+
+def test_tuple_index():
+    # GH 35534 - Selecting values when a Series has an Index of tuples
+    s = Series([1, 2], index=[("a",), ("b",)])
+    assert s[("a",)] == 1
+    assert s[("b",)] == 2
+    s[("b",)] = 3
+    assert s[("b",)] == 3
+
+
+def test_frozenset_index():
+    # GH35747 - Selecting values when a Series has an Index of frozenset
+    idx0, idx1 = frozenset("a"), frozenset("b")
+    s = Series([1, 2], index=[idx0, idx1])
+    assert s[idx0] == 1
+    assert s[idx1] == 2
+    s[idx1] = 3
+    assert s[idx1] == 3
+
+
+def test_loc_setitem_all_false_indexer():
+    # GH#45778
+    ser = Series([1, 2], index=["a", "b"])
+    expected = ser.copy()
+    rhs = Series([6, 7], index=["a", "b"])
+    ser.loc[ser > 100] = rhs
+    tm.assert_series_equal(ser, expected)
+
+
+def test_loc_boolean_indexer_non_matching_index():
+    # GH#46551
+    ser = Series([1])
+    result = ser.loc[Series([NA, False], dtype="boolean")]
+    expected = Series([], dtype="int64")
+    tm.assert_series_equal(result, expected)
+
+
+def test_loc_boolean_indexer_miss_matching_index():
+    # GH#46551
+    ser = Series([1])
+    indexer = Series([NA, False], dtype="boolean", index=[1, 2])
+    with pytest.raises(IndexingError, match="Unalignable"):
+        ser.loc[indexer]
+
+
+def test_loc_setitem_nested_data_enlargement():
+    # GH#48614
+    df = DataFrame({"a": [1]})
+    ser = Series({"label": df})
+    ser.loc["new_label"] = df
+    expected = Series({"label": df, "new_label": df})
+    tm.assert_series_equal(ser, expected)
+
+
+def test_loc_ea_numeric_index_oob_slice_end():
+    # GH#50161
+    ser = Series(1, index=Index([0, 1, 2], dtype="Int64"))
+    result = ser.loc[2:3]
+    expected = Series(1, index=Index([2], dtype="Int64"))
+    tm.assert_series_equal(result, expected)
+
+
+def test_getitem_bool_int_key():
+    # GH#48653
+    ser = Series({True: 1, False: 0})
+    with pytest.raises(KeyError, match="0"):
+        ser.loc[0]
+
+
+@pytest.mark.parametrize("val", [{}, {"b": "x"}])
+@pytest.mark.parametrize("indexer", [[], [False, False], slice(0, -1), np.array([])])
+def test_setitem_empty_indexer(indexer, val):
+    # GH#45981
+    df = DataFrame({"a": [1, 2], **val})
+    expected = df.copy()
+    df.loc[indexer] = 1.5
+    tm.assert_frame_equal(df, expected)
+
+
+class TestDeprecatedIndexers:
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_getitem_dict_and_set_deprecated(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key]
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}, ({1}, 2), ({1: 1}, 2)])
+    def test_getitem_dict_and_set_deprecated_multiindex(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2], index=MultiIndex.from_tuples([(1, 2), (3, 4)]))
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key]
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}])
+    def test_setitem_dict_and_set_disallowed(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2])
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key] = 1
+
+    @pytest.mark.parametrize("key", [{1}, {1: 1}, ({1}, 2), ({1: 1}, 2)])
+    def test_setitem_dict_and_set_disallowed_multiindex(self, key):
+        # GH#42825 enforced in 2.0
+        ser = Series([1, 2], index=MultiIndex.from_tuples([(1, 2), (3, 4)]))
+        with pytest.raises(TypeError, match="as an indexer is not supported"):
+            ser.loc[key] = 1
+
+
+class TestSetitemValidation:
+    # This is adapted from pandas/tests/arrays/masked/test_indexing.py
+    # but checks for warnings instead of errors.
+    def _check_setitem_invalid(self, ser, invalid, indexer, warn):
+        msg = "Setting an item of incompatible dtype is deprecated"
+        msg = re.escape(msg)
+
+        orig_ser = ser.copy()
+
+        with tm.assert_produces_warning(warn, match=msg):
+            ser[indexer] = invalid
+            ser = orig_ser.copy()
+
+        with tm.assert_produces_warning(warn, match=msg):
+            ser.iloc[indexer] = invalid
+            ser = orig_ser.copy()
+
+        with tm.assert_produces_warning(warn, match=msg):
+            ser.loc[indexer] = invalid
+            ser = orig_ser.copy()
+
+        with tm.assert_produces_warning(warn, match=msg):
+            ser[:] = invalid
+
+    _invalid_scalars = [
+        1 + 2j,
+        "True",
+        "1",
+        "1.0",
+        NaT,
+        np.datetime64("NaT"),
+        np.timedelta64("NaT"),
+    ]
+    _indexers = [0, [0], slice(0, 1), [True, False, False]]
+
+    @pytest.mark.parametrize(
+        "invalid", _invalid_scalars + [1, 1.0, np.int64(1), np.float64(1)]
+    )
+    @pytest.mark.parametrize("indexer", _indexers)
+    def test_setitem_validation_scalar_bool(self, invalid, indexer):
+        ser = Series([True, False, False], dtype="bool")
+        self._check_setitem_invalid(ser, invalid, indexer, FutureWarning)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
+    @pytest.mark.parametrize("indexer", _indexers)
+    def test_setitem_validation_scalar_int(self, invalid, any_int_numpy_dtype, indexer):
+        ser = Series([1, 2, 3], dtype=any_int_numpy_dtype)
+        if isna(invalid) and invalid is not NaT:
+            warn = None
+        else:
+            warn = FutureWarning
+        self._check_setitem_invalid(ser, invalid, indexer, warn)
+
+    @pytest.mark.parametrize("invalid", _invalid_scalars + [True])
+    @pytest.mark.parametrize("indexer", _indexers)
+    def test_setitem_validation_scalar_float(self, invalid, float_numpy_dtype, indexer):
+        ser = Series([1, 2, None], dtype=float_numpy_dtype)
+        self._check_setitem_invalid(ser, invalid, indexer, FutureWarning)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_mask.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_mask.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c21cd0d5ca648dcf0f1ac412dd232221c031c6f
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_mask.py
@@ -0,0 +1,69 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_mask():
+    # compare with tested results in test_where
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.where(~cond, np.nan)
+    tm.assert_series_equal(rs, s.mask(cond))
+
+    rs = s.where(~cond)
+    rs2 = s.mask(cond)
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s.where(~cond, -s)
+    rs2 = s.mask(cond, -s)
+    tm.assert_series_equal(rs, rs2)
+
+    cond = Series([True, False, False, True, False], index=s.index)
+    s2 = -(s.abs())
+    rs = s2.where(~cond[:3])
+    rs2 = s2.mask(cond[:3])
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s2.where(~cond[:3], -s2)
+    rs2 = s2.mask(cond[:3], -s2)
+    tm.assert_series_equal(rs, rs2)
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.mask(1)
+    with pytest.raises(ValueError, match=msg):
+        s.mask(cond[:3].values, -s)
+
+
+def test_mask_casts():
+    # dtype changes
+    ser = Series([1, 2, 3, 4])
+    result = ser.mask(ser > 2, np.nan)
+    expected = Series([1, 2, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_mask_casts2():
+    # see gh-21891
+    ser = Series([1, 2])
+    res = ser.mask([True, False])
+
+    exp = Series([np.nan, 2])
+    tm.assert_series_equal(res, exp)
+
+
+def test_mask_inplace():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.copy()
+    rs.mask(cond, inplace=True)
+    tm.assert_series_equal(rs.dropna(), s[~cond])
+    tm.assert_series_equal(rs, s.mask(cond))
+
+    rs = s.copy()
+    rs.mask(cond, -s, inplace=True)
+    tm.assert_series_equal(rs, s.mask(cond, -s))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_set_value.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_set_value.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbe1a8bf296c8106c2cfa3ad519b0a7d44401493
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_set_value.py
@@ -0,0 +1,45 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import (
+    DatetimeIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_series_set_value():
+    # GH#1561
+
+    dates = [datetime(2001, 1, 1), datetime(2001, 1, 2)]
+    index = DatetimeIndex(dates)
+
+    s = Series(dtype=object)
+    s._set_value(dates[0], 1.0)
+    s._set_value(dates[1], np.nan)
+
+    expected = Series([1.0, np.nan], index=index)
+
+    tm.assert_series_equal(s, expected)
+
+
+def test_set_value_dt64(datetime_series):
+    idx = datetime_series.index[10]
+    res = datetime_series._set_value(idx, 0)
+    assert res is None
+    assert datetime_series[idx] == 0
+
+
+def test_set_value_str_index(string_series):
+    # equiv
+    ser = string_series.copy()
+    res = ser._set_value("foobar", 0)
+    assert res is None
+    assert ser.index[-1] == "foobar"
+    assert ser["foobar"] == 0
+
+    ser2 = string_series.copy()
+    ser2.loc["foobar"] = 0
+    assert ser2.index[-1] == "foobar"
+    assert ser2["foobar"] == 0
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_setitem.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_setitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..d42e884c1ac786602814079cea18b262f5b9ee43
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_setitem.py
@@ -0,0 +1,1811 @@
+from datetime import (
+    date,
+    datetime,
+)
+
+import numpy as np
+import pytest
+
+from pandas.errors import IndexingError
+
+from pandas.core.dtypes.common import is_list_like
+
+from pandas import (
+    NA,
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Interval,
+    IntervalIndex,
+    MultiIndex,
+    NaT,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    array,
+    concat,
+    date_range,
+    interval_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+from pandas.tseries.offsets import BDay
+
+
+class TestSetitemDT64Values:
+    def test_setitem_none_nan(self):
+        series = Series(date_range("1/1/2000", periods=10))
+        series[3] = None
+        assert series[3] is NaT
+
+        series[3:5] = None
+        assert series[4] is NaT
+
+        series[5] = np.nan
+        assert series[5] is NaT
+
+        series[5:7] = np.nan
+        assert series[6] is NaT
+
+    def test_setitem_multiindex_empty_slice(self):
+        # https://github.com/pandas-dev/pandas/issues/35878
+        idx = MultiIndex.from_tuples([("a", 1), ("b", 2)])
+        result = Series([1, 2], index=idx)
+        expected = result.copy()
+        result.loc[[]] = 0
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_with_string_index(self):
+        # GH#23451
+        # Set object dtype to avoid upcast when setting date.today()
+        ser = Series([1, 2, 3], index=["Date", "b", "other"], dtype=object)
+        ser["Date"] = date.today()
+        assert ser.Date == date.today()
+        assert ser["Date"] == date.today()
+
+    def test_setitem_tuple_with_datetimetz_values(self):
+        # GH#20441
+        arr = date_range("2017", periods=4, tz="US/Eastern")
+        index = [(0, 1), (0, 2), (0, 3), (0, 4)]
+        result = Series(arr, index=index)
+        expected = result.copy()
+        result[(0, 1)] = np.nan
+        expected.iloc[0] = np.nan
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Tokyo"])
+    def test_setitem_with_tz(self, tz, indexer_sli):
+        orig = Series(date_range("2016-01-01", freq="H", periods=3, tz=tz))
+        assert orig.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-01-01 00:00", tz=tz),
+                Timestamp("2011-01-01 00:00", tz=tz),
+                Timestamp("2016-01-01 02:00", tz=tz),
+            ]
+        )
+
+        # scalar
+        ser = orig.copy()
+        indexer_sli(ser)[1] = Timestamp("2011-01-01", tz=tz)
+        tm.assert_series_equal(ser, exp)
+
+        # vector
+        vals = Series(
+            [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)],
+            index=[1, 2],
+        )
+        assert vals.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-01-01 00:00", tz=tz),
+                Timestamp("2011-01-01 00:00", tz=tz),
+                Timestamp("2012-01-01 00:00", tz=tz),
+            ]
+        )
+
+        ser = orig.copy()
+        indexer_sli(ser)[[1, 2]] = vals
+        tm.assert_series_equal(ser, exp)
+
+    def test_setitem_with_tz_dst(self, indexer_sli):
+        # GH#14146 trouble setting values near DST boundary
+        tz = "US/Eastern"
+        orig = Series(date_range("2016-11-06", freq="H", periods=3, tz=tz))
+        assert orig.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-11-06 00:00-04:00", tz=tz),
+                Timestamp("2011-01-01 00:00-05:00", tz=tz),
+                Timestamp("2016-11-06 01:00-05:00", tz=tz),
+            ]
+        )
+
+        # scalar
+        ser = orig.copy()
+        indexer_sli(ser)[1] = Timestamp("2011-01-01", tz=tz)
+        tm.assert_series_equal(ser, exp)
+
+        # vector
+        vals = Series(
+            [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)],
+            index=[1, 2],
+        )
+        assert vals.dtype == f"datetime64[ns, {tz}]"
+
+        exp = Series(
+            [
+                Timestamp("2016-11-06 00:00", tz=tz),
+                Timestamp("2011-01-01 00:00", tz=tz),
+                Timestamp("2012-01-01 00:00", tz=tz),
+            ]
+        )
+
+        ser = orig.copy()
+        indexer_sli(ser)[[1, 2]] = vals
+        tm.assert_series_equal(ser, exp)
+
+    def test_object_series_setitem_dt64array_exact_match(self):
+        # make sure the dt64 isn't cast by numpy to integers
+        # https://github.com/numpy/numpy/issues/12550
+
+        ser = Series({"X": np.nan}, dtype=object)
+
+        indexer = [True]
+
+        # "exact_match" -> size of array being set matches size of ser
+        value = np.array([4], dtype="M8[ns]")
+
+        ser.iloc[indexer] = value
+
+        expected = Series([value[0]], index=["X"], dtype=object)
+        assert all(isinstance(x, np.datetime64) for x in expected.values)
+
+        tm.assert_series_equal(ser, expected)
+
+
+class TestSetitemScalarIndexer:
+    def test_setitem_negative_out_of_bounds(self):
+        ser = Series(["a"] * 10, index=["a"] * 10)
+
+        msg = "index -11 is out of bounds for axis 0 with size 10"
+        warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
+        with pytest.raises(IndexError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+                ser[-11] = "foo"
+
+    @pytest.mark.parametrize("indexer", [tm.loc, tm.at])
+    @pytest.mark.parametrize("ser_index", [0, 1])
+    def test_setitem_series_object_dtype(self, indexer, ser_index):
+        # GH#38303
+        ser = Series([0, 0], dtype="object")
+        idxr = indexer(ser)
+        idxr[0] = Series([42], index=[ser_index])
+        expected = Series([Series([42], index=[ser_index]), 0], dtype="object")
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize("index, exp_value", [(0, 42), (1, np.nan)])
+    def test_setitem_series(self, index, exp_value):
+        # GH#38303
+        ser = Series([0, 0])
+        ser.loc[0] = Series([42], index=[index])
+        expected = Series([exp_value, 0])
+        tm.assert_series_equal(ser, expected)
+
+
+class TestSetitemSlices:
+    def test_setitem_slice_float_raises(self, datetime_series):
+        msg = (
+            "cannot do slice indexing on DatetimeIndex with these indexers "
+            r"\[{key}\] of type float"
+        )
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.0")):
+            datetime_series[4.0:10.0] = 0
+
+        with pytest.raises(TypeError, match=msg.format(key=r"4\.5")):
+            datetime_series[4.5:10.0] = 0
+
+    def test_setitem_slice(self):
+        ser = Series(range(10), index=list(range(10)))
+        ser[-12:] = 0
+        assert (ser == 0).all()
+
+        ser[:-12] = 5
+        assert (ser == 0).all()
+
+    def test_setitem_slice_integers(self):
+        ser = Series(
+            np.random.default_rng(2).standard_normal(8),
+            index=[2, 4, 6, 8, 10, 12, 14, 16],
+        )
+
+        ser[:4] = 0
+        assert (ser[:4] == 0).all()
+        assert not (ser[4:] == 0).any()
+
+    def test_setitem_slicestep(self):
+        # caught this bug when writing tests
+        series = Series(tm.makeIntIndex(20).astype(float), index=tm.makeIntIndex(20))
+
+        series[::2] = 0
+        assert (series[::2] == 0).all()
+
+    def test_setitem_multiindex_slice(self, indexer_sli):
+        # GH 8856
+        mi = MultiIndex.from_product(([0, 1], list("abcde")))
+        result = Series(np.arange(10, dtype=np.int64), mi)
+        indexer_sli(result)[::4] = 100
+        expected = Series([100, 1, 2, 3, 100, 5, 6, 7, 100, 9], mi)
+        tm.assert_series_equal(result, expected)
+
+
+class TestSetitemBooleanMask:
+    def test_setitem_mask_cast(self):
+        # GH#2746
+        # need to upcast
+        ser = Series([1, 2], index=[1, 2], dtype="int64")
+        ser[[True, False]] = Series([0], index=[1], dtype="int64")
+        expected = Series([0, 2], index=[1, 2], dtype="int64")
+
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_mask_align_and_promote(self):
+        # GH#8387: test that changing types does not break alignment
+        ts = Series(
+            np.random.default_rng(2).standard_normal(100), index=np.arange(100, 0, -1)
+        ).round(5)
+        mask = ts > 0
+        left = ts.copy()
+        right = ts[mask].copy().map(str)
+        with tm.assert_produces_warning(
+            FutureWarning, match="item of incompatible dtype"
+        ):
+            left[mask] = right
+        expected = ts.map(lambda t: str(t) if t > 0 else t)
+        tm.assert_series_equal(left, expected)
+
+    def test_setitem_mask_promote_strs(self):
+        ser = Series([0, 1, 2, 0])
+        mask = ser > 0
+        ser2 = ser[mask].map(str)
+        with tm.assert_produces_warning(
+            FutureWarning, match="item of incompatible dtype"
+        ):
+            ser[mask] = ser2
+
+        expected = Series([0, "1", "2", 0])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_mask_promote(self):
+        ser = Series([0, "foo", "bar", 0])
+        mask = Series([False, True, True, False])
+        ser2 = ser[mask]
+        ser[mask] = ser2
+
+        expected = Series([0, "foo", "bar", 0])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_boolean(self, string_series):
+        mask = string_series > string_series.median()
+
+        # similar indexed series
+        result = string_series.copy()
+        result[mask] = string_series * 2
+        expected = string_series * 2
+        tm.assert_series_equal(result[mask], expected[mask])
+
+        # needs alignment
+        result = string_series.copy()
+        result[mask] = (string_series * 2)[0:5]
+        expected = (string_series * 2)[0:5].reindex_like(string_series)
+        expected[-mask] = string_series[mask]
+        tm.assert_series_equal(result[mask], expected[mask])
+
+    def test_setitem_boolean_corner(self, datetime_series):
+        ts = datetime_series
+        mask_shifted = ts.shift(1, freq=BDay()) > ts.median()
+
+        msg = (
+            r"Unalignable boolean Series provided as indexer \(index of "
+            r"the boolean Series and of the indexed object do not match"
+        )
+        with pytest.raises(IndexingError, match=msg):
+            ts[mask_shifted] = 1
+
+        with pytest.raises(IndexingError, match=msg):
+            ts.loc[mask_shifted] = 1
+
+    def test_setitem_boolean_different_order(self, string_series):
+        ordered = string_series.sort_values()
+
+        copy = string_series.copy()
+        copy[ordered > 0] = 0
+
+        expected = string_series.copy()
+        expected[expected > 0] = 0
+
+        tm.assert_series_equal(copy, expected)
+
+    @pytest.mark.parametrize("func", [list, np.array, Series])
+    def test_setitem_boolean_python_list(self, func):
+        # GH19406
+        ser = Series([None, "b", None])
+        mask = func([True, False, True])
+        ser[mask] = ["a", "c"]
+        expected = Series(["a", "b", "c"])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_boolean_nullable_int_types(self, any_numeric_ea_dtype):
+        # GH: 26468
+        ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype)
+        ser[ser > 6] = Series(range(4), dtype=any_numeric_ea_dtype)
+        expected = Series([5, 6, 2, 3], dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype)
+        ser.loc[ser > 6] = Series(range(4), dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype)
+        loc_ser = Series(range(4), dtype=any_numeric_ea_dtype)
+        ser.loc[ser > 6] = loc_ser.loc[loc_ser > 1]
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_with_bool_mask_and_values_matching_n_trues_in_length(self):
+        # GH#30567
+        ser = Series([None] * 10)
+        mask = [False] * 3 + [True] * 5 + [False] * 2
+        ser[mask] = range(5)
+        result = ser
+        expected = Series([None] * 3 + list(range(5)) + [None] * 2, dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_nan_with_bool(self):
+        # GH 13034
+        result = Series([True, False, True])
+        with tm.assert_produces_warning(
+            FutureWarning, match="item of incompatible dtype"
+        ):
+            result[0] = np.nan
+        expected = Series([np.nan, False, True], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_setitem_mask_smallint_upcast(self):
+        orig = Series([1, 2, 3], dtype="int8")
+        alt = np.array([999, 1000, 1001], dtype=np.int64)
+
+        mask = np.array([True, False, True])
+
+        ser = orig.copy()
+        with tm.assert_produces_warning(
+            FutureWarning, match="item of incompatible dtype"
+        ):
+            ser[mask] = Series(alt)
+        expected = Series([999, 2, 1001])
+        tm.assert_series_equal(ser, expected)
+
+        ser2 = orig.copy()
+        with tm.assert_produces_warning(
+            FutureWarning, match="item of incompatible dtype"
+        ):
+            ser2.mask(mask, alt, inplace=True)
+        tm.assert_series_equal(ser2, expected)
+
+        ser3 = orig.copy()
+        res = ser3.where(~mask, Series(alt))
+        tm.assert_series_equal(res, expected)
+
+    def test_setitem_mask_smallint_no_upcast(self):
+        # like test_setitem_mask_smallint_upcast, but while we can't hold 'alt',
+        #  we *can* hold alt[mask] without casting
+        orig = Series([1, 2, 3], dtype="uint8")
+        alt = Series([245, 1000, 246], dtype=np.int64)
+
+        mask = np.array([True, False, True])
+
+        ser = orig.copy()
+        ser[mask] = alt
+        expected = Series([245, 2, 246], dtype="uint8")
+        tm.assert_series_equal(ser, expected)
+
+        ser2 = orig.copy()
+        ser2.mask(mask, alt, inplace=True)
+        tm.assert_series_equal(ser2, expected)
+
+        # TODO: ser.where(~mask, alt) unnecessarily upcasts to int64
+        ser3 = orig.copy()
+        res = ser3.where(~mask, alt)
+        tm.assert_series_equal(res, expected, check_dtype=False)
+
+
+class TestSetitemViewCopySemantics:
+    def test_setitem_invalidates_datetime_index_freq(self, using_copy_on_write):
+        # GH#24096 altering a datetime64tz Series inplace invalidates the
+        #  `freq` attribute on the underlying DatetimeIndex
+
+        dti = date_range("20130101", periods=3, tz="US/Eastern")
+        ts = dti[1]
+        ser = Series(dti)
+        assert ser._values is not dti
+        if using_copy_on_write:
+            assert ser._values._ndarray.base is dti._data._ndarray.base
+        else:
+            assert ser._values._ndarray.base is not dti._data._ndarray.base
+        assert dti.freq == "D"
+        ser.iloc[1] = NaT
+        assert ser._values.freq is None
+
+        # check that the DatetimeIndex was not altered in place
+        assert ser._values is not dti
+        assert ser._values._ndarray.base is not dti._data._ndarray.base
+        assert dti[1] == ts
+        assert dti.freq == "D"
+
+    def test_dt64tz_setitem_does_not_mutate_dti(self, using_copy_on_write):
+        # GH#21907, GH#24096
+        dti = date_range("2016-01-01", periods=10, tz="US/Pacific")
+        ts = dti[0]
+        ser = Series(dti)
+        assert ser._values is not dti
+        if using_copy_on_write:
+            assert ser._values._ndarray.base is dti._data._ndarray.base
+            assert ser._mgr.arrays[0]._ndarray.base is dti._data._ndarray.base
+        else:
+            assert ser._values._ndarray.base is not dti._data._ndarray.base
+            assert ser._mgr.arrays[0]._ndarray.base is not dti._data._ndarray.base
+
+        assert ser._mgr.arrays[0] is not dti
+
+        ser[::3] = NaT
+        assert ser[0] is NaT
+        assert dti[0] == ts
+
+
+class TestSetitemCallable:
+    def test_setitem_callable_key(self):
+        # GH#12533
+        ser = Series([1, 2, 3, 4], index=list("ABCD"))
+        ser[lambda x: "A"] = -1
+
+        expected = Series([-1, 2, 3, 4], index=list("ABCD"))
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_callable_other(self):
+        # GH#13299
+        inc = lambda x: x + 1
+
+        # set object dtype to avoid upcast when setting inc
+        ser = Series([1, 2, -1, 4], dtype=object)
+        ser[ser < 0] = inc
+
+        expected = Series([1, 2, inc, 4])
+        tm.assert_series_equal(ser, expected)
+
+
+class TestSetitemWithExpansion:
+    def test_setitem_empty_series(self):
+        # GH#10193
+        key = Timestamp("2012-01-01")
+        series = Series(dtype=object)
+        series[key] = 47
+        expected = Series(47, [key])
+        tm.assert_series_equal(series, expected)
+
+    def test_setitem_empty_series_datetimeindex_preserves_freq(self):
+        # GH#33573 our index should retain its freq
+        series = Series([], DatetimeIndex([], freq="D"), dtype=object)
+        key = Timestamp("2012-01-01")
+        series[key] = 47
+        expected = Series(47, DatetimeIndex([key], freq="D"))
+        tm.assert_series_equal(series, expected)
+        assert series.index.freq == expected.index.freq
+
+    def test_setitem_empty_series_timestamp_preserves_dtype(self):
+        # GH 21881
+        timestamp = Timestamp(1412526600000000000)
+        series = Series([timestamp], index=["timestamp"], dtype=object)
+        expected = series["timestamp"]
+
+        series = Series([], dtype=object)
+        series["anything"] = 300.0
+        series["timestamp"] = timestamp
+        result = series["timestamp"]
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "td",
+        [
+            Timedelta("9 days"),
+            Timedelta("9 days").to_timedelta64(),
+            Timedelta("9 days").to_pytimedelta(),
+        ],
+    )
+    def test_append_timedelta_does_not_cast(self, td):
+        # GH#22717 inserting a Timedelta should _not_ cast to int64
+        expected = Series(["x", td], index=[0, "td"], dtype=object)
+
+        ser = Series(["x"])
+        ser["td"] = td
+        tm.assert_series_equal(ser, expected)
+        assert isinstance(ser["td"], Timedelta)
+
+        ser = Series(["x"])
+        ser.loc["td"] = Timedelta("9 days")
+        tm.assert_series_equal(ser, expected)
+        assert isinstance(ser["td"], Timedelta)
+
+    def test_setitem_with_expansion_type_promotion(self):
+        # GH#12599
+        ser = Series(dtype=object)
+        ser["a"] = Timestamp("2016-01-01")
+        ser["b"] = 3.0
+        ser["c"] = "foo"
+        expected = Series([Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_not_contained(self, string_series):
+        # set item that's not contained
+        ser = string_series.copy()
+        assert "foobar" not in ser.index
+        ser["foobar"] = 1
+
+        app = Series([1], index=["foobar"], name="series")
+        expected = concat([string_series, app])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_keep_precision(self, any_numeric_ea_dtype):
+        # GH#32346
+        ser = Series([1, 2], dtype=any_numeric_ea_dtype)
+        ser[2] = 10
+        expected = Series([1, 2, 10], dtype=any_numeric_ea_dtype)
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize(
+        "na, target_na, dtype, target_dtype, indexer, warn",
+        [
+            (NA, NA, "Int64", "Int64", 1, None),
+            (NA, NA, "Int64", "Int64", 2, None),
+            (NA, np.nan, "int64", "float64", 1, None),
+            (NA, np.nan, "int64", "float64", 2, None),
+            (NaT, NaT, "int64", "object", 1, FutureWarning),
+            (NaT, NaT, "int64", "object", 2, None),
+            (np.nan, NA, "Int64", "Int64", 1, None),
+            (np.nan, NA, "Int64", "Int64", 2, None),
+            (np.nan, NA, "Float64", "Float64", 1, None),
+            (np.nan, NA, "Float64", "Float64", 2, None),
+            (np.nan, np.nan, "int64", "float64", 1, None),
+            (np.nan, np.nan, "int64", "float64", 2, None),
+        ],
+    )
+    def test_setitem_enlarge_with_na(
+        self, na, target_na, dtype, target_dtype, indexer, warn
+    ):
+        # GH#32346
+        ser = Series([1, 2], dtype=dtype)
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            ser[indexer] = na
+        expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na]
+        expected = Series(expected_values, dtype=target_dtype)
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_enlargement_object_none(self, nulls_fixture):
+        # GH#48665
+        ser = Series(["a", "b"])
+        ser[3] = nulls_fixture
+        expected = Series(["a", "b", nulls_fixture], index=[0, 1, 3])
+        tm.assert_series_equal(ser, expected)
+        assert ser[3] is nulls_fixture
+
+
+def test_setitem_scalar_into_readonly_backing_data():
+    # GH#14359: test that you cannot mutate a read only buffer
+
+    array = np.zeros(5)
+    array.flags.writeable = False  # make the array immutable
+    series = Series(array, copy=False)
+
+    for n in series.index:
+        msg = "assignment destination is read-only"
+        with pytest.raises(ValueError, match=msg):
+            series[n] = 1
+
+        assert array[n] == 0
+
+
+def test_setitem_slice_into_readonly_backing_data():
+    # GH#14359: test that you cannot mutate a read only buffer
+
+    array = np.zeros(5)
+    array.flags.writeable = False  # make the array immutable
+    series = Series(array, copy=False)
+
+    msg = "assignment destination is read-only"
+    with pytest.raises(ValueError, match=msg):
+        series[1:3] = 1
+
+    assert not array.any()
+
+
+def test_setitem_categorical_assigning_ops():
+    orig = Series(Categorical(["b", "b"], categories=["a", "b"]))
+    ser = orig.copy()
+    ser[:] = "a"
+    exp = Series(Categorical(["a", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser[1] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser[ser.index > 0] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser[[False, True]] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]))
+    tm.assert_series_equal(ser, exp)
+
+    ser = orig.copy()
+    ser.index = ["x", "y"]
+    ser["y"] = "a"
+    exp = Series(Categorical(["b", "a"], categories=["a", "b"]), index=["x", "y"])
+    tm.assert_series_equal(ser, exp)
+
+
+def test_setitem_nan_into_categorical():
+    # ensure that one can set something to np.nan
+    ser = Series(Categorical([1, 2, 3]))
+    exp = Series(Categorical([1, np.nan, 3], categories=[1, 2, 3]))
+    ser[1] = np.nan
+    tm.assert_series_equal(ser, exp)
+
+
+class TestSetitemCasting:
+    @pytest.mark.parametrize("unique", [True, False])
+    @pytest.mark.parametrize("val", [3, 3.0, "3"], ids=type)
+    def test_setitem_non_bool_into_bool(self, val, indexer_sli, unique):
+        # dont cast these 3-like values to bool
+        ser = Series([True, False])
+        if not unique:
+            ser.index = [1, 1]
+
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            indexer_sli(ser)[1] = val
+        assert type(ser.iloc[1]) == type(val)
+
+        expected = Series([True, val], dtype=object, index=ser.index)
+        if not unique and indexer_sli is not tm.iloc:
+            expected = Series([val, val], dtype=object, index=[1, 1])
+        tm.assert_series_equal(ser, expected)
+
+    def test_setitem_boolean_array_into_npbool(self):
+        # GH#45462
+        ser = Series([True, False, True])
+        values = ser._values
+        arr = array([True, False, None])
+
+        ser[:2] = arr[:2]  # no NAs -> can set inplace
+        assert ser._values is values
+
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            ser[1:] = arr[1:]  # has an NA -> cast to boolean dtype
+        expected = Series(arr)
+        tm.assert_series_equal(ser, expected)
+
+
+class SetitemCastingEquivalents:
+    """
+    Check each of several methods that _should_ be equivalent to `obj[key] = val`
+
+    We assume that
+        - obj.index is the default Index(range(len(obj)))
+        - the setitem does not expand the obj
+    """
+
+    @pytest.fixture
+    def is_inplace(self, obj, expected):
+        """
+        Whether we expect the setting to be in-place or not.
+        """
+        return expected.dtype == obj.dtype
+
+    def check_indexer(self, obj, key, expected, val, indexer, is_inplace):
+        orig = obj
+        obj = obj.copy()
+        arr = obj._values
+
+        indexer(obj)[key] = val
+        tm.assert_series_equal(obj, expected)
+
+        self._check_inplace(is_inplace, orig, arr, obj)
+
+    def _check_inplace(self, is_inplace, orig, arr, obj):
+        if is_inplace is None:
+            # We are not (yet) checking whether setting is inplace or not
+            pass
+        elif is_inplace:
+            if arr.dtype.kind in ["m", "M"]:
+                # We may not have the same DTA/TDA, but will have the same
+                #  underlying data
+                assert arr._ndarray is obj._values._ndarray
+            else:
+                assert obj._values is arr
+        else:
+            # otherwise original array should be unchanged
+            tm.assert_equal(arr, orig._values)
+
+    def test_int_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace):
+        if not isinstance(key, int):
+            pytest.skip("Not relevant for int key")
+
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace)
+
+        if indexer_sli is tm.loc:
+            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+                self.check_indexer(obj, key, expected, val, tm.at, is_inplace)
+        elif indexer_sli is tm.iloc:
+            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+                self.check_indexer(obj, key, expected, val, tm.iat, is_inplace)
+
+        rng = range(key, key + 1)
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, rng, expected, val, indexer_sli, is_inplace)
+
+        if indexer_sli is not tm.loc:
+            # Note: no .loc because that handles slice edges differently
+            slc = slice(key, key + 1)
+            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+                self.check_indexer(obj, slc, expected, val, indexer_sli, is_inplace)
+
+        ilkey = [key]
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace)
+
+        indkey = np.array(ilkey)
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace)
+
+        genkey = (x for x in [key])
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace)
+
+    def test_slice_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace):
+        if not isinstance(key, slice):
+            pytest.skip("Not relevant for slice key")
+
+        if indexer_sli is not tm.loc:
+            # Note: no .loc because that handles slice edges differently
+            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+                self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace)
+
+        ilkey = list(range(len(obj)))[key]
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace)
+
+        indkey = np.array(ilkey)
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace)
+
+        genkey = (x for x in indkey)
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace)
+
+    def test_mask_key(self, obj, key, expected, warn, val, indexer_sli):
+        # setitem with boolean mask
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        obj = obj.copy()
+
+        if is_list_like(val) and len(val) < mask.sum():
+            msg = "boolean index did not match indexed array along dimension"
+            with pytest.raises(IndexError, match=msg):
+                indexer_sli(obj)[mask] = val
+            return
+
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            indexer_sli(obj)[mask] = val
+        tm.assert_series_equal(obj, expected)
+
+    def test_series_where(self, obj, key, expected, warn, val, is_inplace):
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        if is_list_like(val) and len(val) < len(obj):
+            # Series.where is not valid here
+            msg = "operands could not be broadcast together with shapes"
+            with pytest.raises(ValueError, match=msg):
+                obj.where(~mask, val)
+            return
+
+        orig = obj
+        obj = obj.copy()
+        arr = obj._values
+
+        res = obj.where(~mask, val)
+
+        if val is NA and res.dtype == object:
+            expected = expected.fillna(NA)
+        elif val is None and res.dtype == object:
+            assert expected.dtype == object
+            expected = expected.copy()
+            expected[expected.isna()] = None
+        tm.assert_series_equal(res, expected)
+
+        self._check_inplace(is_inplace, orig, arr, obj)
+
+    def test_index_where(self, obj, key, expected, warn, val):
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        res = Index(obj).where(~mask, val)
+        expected_idx = Index(expected, dtype=expected.dtype)
+        tm.assert_index_equal(res, expected_idx)
+
+    def test_index_putmask(self, obj, key, expected, warn, val):
+        mask = np.zeros(obj.shape, dtype=bool)
+        mask[key] = True
+
+        res = Index(obj).putmask(mask, val)
+        tm.assert_index_equal(res, Index(expected, dtype=expected.dtype))
+
+
+@pytest.mark.parametrize(
+    "obj,expected,key,warn",
+    [
+        pytest.param(
+            # GH#45568 setting a valid NA value into IntervalDtype[int] should
+            #  cast to IntervalDtype[float]
+            Series(interval_range(1, 5)),
+            Series(
+                [Interval(1, 2), np.nan, Interval(3, 4), Interval(4, 5)],
+                dtype="interval[float64]",
+            ),
+            1,
+            FutureWarning,
+            id="interval_int_na_value",
+        ),
+        pytest.param(
+            # these induce dtype changes
+            Series([2, 3, 4, 5, 6, 7, 8, 9, 10]),
+            Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan]),
+            slice(None, None, 2),
+            None,
+            id="int_series_slice_key_step",
+        ),
+        pytest.param(
+            Series([True, True, False, False]),
+            Series([np.nan, True, np.nan, False], dtype=object),
+            slice(None, None, 2),
+            FutureWarning,
+            id="bool_series_slice_key_step",
+        ),
+        pytest.param(
+            # these induce dtype changes
+            Series(np.arange(10)),
+            Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8, 9]),
+            slice(None, 5),
+            None,
+            id="int_series_slice_key",
+        ),
+        pytest.param(
+            # changes dtype GH#4463
+            Series([1, 2, 3]),
+            Series([np.nan, 2, 3]),
+            0,
+            None,
+            id="int_series_int_key",
+        ),
+        pytest.param(
+            # changes dtype GH#4463
+            Series([False]),
+            Series([np.nan], dtype=object),
+            # TODO: maybe go to float64 since we are changing the _whole_ Series?
+            0,
+            FutureWarning,
+            id="bool_series_int_key_change_all",
+        ),
+        pytest.param(
+            # changes dtype GH#4463
+            Series([False, True]),
+            Series([np.nan, True], dtype=object),
+            0,
+            FutureWarning,
+            id="bool_series_int_key",
+        ),
+    ],
+)
+class TestSetitemCastingEquivalents(SetitemCastingEquivalents):
+    @pytest.fixture(params=[np.nan, np.float64("NaN"), None, NA])
+    def val(self, request):
+        """
+        NA values that should generally be valid_na for *all* dtypes.
+
+        Include both python float NaN and np.float64; only np.float64 has a
+        `dtype` attribute.
+        """
+        return request.param
+
+
+class TestSetitemTimedelta64IntoNumeric(SetitemCastingEquivalents):
+    # timedelta64 should not be treated as integers when setting into
+    #  numeric Series
+
+    @pytest.fixture
+    def val(self):
+        td = np.timedelta64(4, "ns")
+        return td
+        # TODO: could also try np.full((1,), td)
+
+    @pytest.fixture(params=[complex, int, float])
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def obj(self, dtype):
+        arr = np.arange(5).astype(dtype)
+        ser = Series(arr)
+        return ser
+
+    @pytest.fixture
+    def expected(self, dtype):
+        arr = np.arange(5).astype(dtype)
+        ser = Series(arr)
+        ser = ser.astype(object)
+        ser.iloc[0] = np.timedelta64(4, "ns")
+        return ser
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def warn(self):
+        return FutureWarning
+
+
+class TestSetitemDT64IntoInt(SetitemCastingEquivalents):
+    # GH#39619 dont cast dt64 to int when doing this setitem
+
+    @pytest.fixture(params=["M8[ns]", "m8[ns]"])
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def scalar(self, dtype):
+        val = np.datetime64("2021-01-18 13:25:00", "ns")
+        if dtype == "m8[ns]":
+            val = val - val
+        return val
+
+    @pytest.fixture
+    def expected(self, scalar):
+        expected = Series([scalar, scalar, 3], dtype=object)
+        assert isinstance(expected[0], type(scalar))
+        return expected
+
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3])
+
+    @pytest.fixture
+    def key(self):
+        return slice(None, -1)
+
+    @pytest.fixture(params=[None, list, np.array])
+    def val(self, scalar, request):
+        box = request.param
+        if box is None:
+            return scalar
+        return box([scalar, scalar])
+
+    @pytest.fixture
+    def warn(self):
+        return FutureWarning
+
+
+class TestSetitemNAPeriodDtype(SetitemCastingEquivalents):
+    # Setting compatible NA values into Series with PeriodDtype
+
+    @pytest.fixture
+    def expected(self, key):
+        exp = Series(period_range("2000-01-01", periods=10, freq="D"))
+        exp._values.view("i8")[key] = NaT._value
+        assert exp[key] is NaT or all(x is NaT for x in exp[key])
+        return exp
+
+    @pytest.fixture
+    def obj(self):
+        return Series(period_range("2000-01-01", periods=10, freq="D"))
+
+    @pytest.fixture(params=[3, slice(3, 5)])
+    def key(self, request):
+        return request.param
+
+    @pytest.fixture(params=[None, np.nan])
+    def val(self, request):
+        return request.param
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+class TestSetitemNADatetimeLikeDtype(SetitemCastingEquivalents):
+    # some nat-like values should be cast to datetime64/timedelta64 when
+    #  inserting into a datetime64/timedelta64 series.  Others should coerce
+    #  to object and retain their dtypes.
+    # GH#18586 for td64 and boolean mask case
+
+    @pytest.fixture(
+        params=["m8[ns]", "M8[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Central]"]
+    )
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def obj(self, dtype):
+        i8vals = date_range("2016-01-01", periods=3).asi8
+        idx = Index(i8vals, dtype=dtype)
+        assert idx.dtype == dtype
+        return Series(idx)
+
+    @pytest.fixture(
+        params=[
+            None,
+            np.nan,
+            NaT,
+            np.timedelta64("NaT", "ns"),
+            np.datetime64("NaT", "ns"),
+        ]
+    )
+    def val(self, request):
+        return request.param
+
+    @pytest.fixture
+    def is_inplace(self, val, obj):
+        # td64   -> cast to object iff val is datetime64("NaT")
+        # dt64   -> cast to object iff val is timedelta64("NaT")
+        # dt64tz -> cast to object with anything _but_ NaT
+        return val is NaT or val is None or val is np.nan or obj.dtype == val.dtype
+
+    @pytest.fixture
+    def expected(self, obj, val, is_inplace):
+        dtype = obj.dtype if is_inplace else object
+        expected = Series([val] + list(obj[1:]), dtype=dtype)
+        return expected
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def warn(self, is_inplace):
+        return None if is_inplace else FutureWarning
+
+
+class TestSetitemMismatchedTZCastsToObject(SetitemCastingEquivalents):
+    # GH#24024
+    @pytest.fixture
+    def obj(self):
+        return Series(date_range("2000", periods=2, tz="US/Central"))
+
+    @pytest.fixture
+    def val(self):
+        return Timestamp("2000", tz="US/Eastern")
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def expected(self, obj, val):
+        # pre-2.0 this would cast to object, in 2.0 we cast the val to
+        #  the target tz
+        expected = Series(
+            [
+                val.tz_convert("US/Central"),
+                Timestamp("2000-01-02 00:00:00-06:00", tz="US/Central"),
+            ],
+            dtype=obj.dtype,
+        )
+        return expected
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+@pytest.mark.parametrize(
+    "obj,expected,warn",
+    [
+        # For numeric series, we should coerce to NaN.
+        (Series([1, 2, 3]), Series([np.nan, 2, 3]), None),
+        (Series([1.0, 2.0, 3.0]), Series([np.nan, 2.0, 3.0]), None),
+        # For datetime series, we should coerce to NaT.
+        (
+            Series([datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]),
+            Series([NaT, datetime(2000, 1, 2), datetime(2000, 1, 3)]),
+            None,
+        ),
+        # For objects, we should preserve the None value.
+        (Series(["foo", "bar", "baz"]), Series([None, "bar", "baz"]), None),
+    ],
+)
+class TestSeriesNoneCoercion(SetitemCastingEquivalents):
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def val(self):
+        return None
+
+
+class TestSetitemFloatIntervalWithIntIntervalValues(SetitemCastingEquivalents):
+    # GH#44201 Cast to shared IntervalDtype rather than object
+
+    def test_setitem_example(self):
+        # Just a case here to make obvious what this test class is aimed at
+        idx = IntervalIndex.from_breaks(range(4))
+        obj = Series(idx)
+        val = Interval(0.5, 1.5)
+
+        with tm.assert_produces_warning(
+            FutureWarning, match="Setting an item of incompatible dtype"
+        ):
+            obj[0] = val
+        assert obj.dtype == "Interval[float64, right]"
+
+    @pytest.fixture
+    def obj(self):
+        idx = IntervalIndex.from_breaks(range(4))
+        return Series(idx)
+
+    @pytest.fixture
+    def val(self):
+        return Interval(0.5, 1.5)
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def expected(self, obj, val):
+        data = [val] + list(obj[1:])
+        idx = IntervalIndex(data, dtype="Interval[float64]")
+        return Series(idx)
+
+    @pytest.fixture
+    def warn(self):
+        return FutureWarning
+
+
+class TestSetitemRangeIntoIntegerSeries(SetitemCastingEquivalents):
+    # GH#44261 Setting a range with sufficiently-small integers into
+    #  small-itemsize integer dtypes should not need to upcast
+
+    @pytest.fixture
+    def obj(self, any_int_numpy_dtype):
+        dtype = np.dtype(any_int_numpy_dtype)
+        ser = Series(range(5), dtype=dtype)
+        return ser
+
+    @pytest.fixture
+    def val(self):
+        return range(2, 4)
+
+    @pytest.fixture
+    def key(self):
+        return slice(0, 2)
+
+    @pytest.fixture
+    def expected(self, any_int_numpy_dtype):
+        dtype = np.dtype(any_int_numpy_dtype)
+        exp = Series([2, 3, 2, 3, 4], dtype=dtype)
+        return exp
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+@pytest.mark.parametrize(
+    "val, warn",
+    [
+        (np.array([2.0, 3.0]), None),
+        (np.array([2.5, 3.5]), FutureWarning),
+        (
+            np.array([2**65, 2**65 + 1], dtype=np.float64),
+            FutureWarning,
+        ),  # all ints, but can't cast
+    ],
+)
+class TestSetitemFloatNDarrayIntoIntegerSeries(SetitemCastingEquivalents):
+    @pytest.fixture
+    def obj(self):
+        return Series(range(5), dtype=np.int64)
+
+    @pytest.fixture
+    def key(self):
+        return slice(0, 2)
+
+    @pytest.fixture
+    def expected(self, val):
+        if val[0] == 2:
+            # NB: this condition is based on currently-hardcoded "val" cases
+            dtype = np.int64
+        else:
+            dtype = np.float64
+        res_values = np.array(range(5), dtype=dtype)
+        res_values[:2] = val
+        return Series(res_values)
+
+
+@pytest.mark.parametrize("val", [512, np.int16(512)])
+class TestSetitemIntoIntegerSeriesNeedsUpcast(SetitemCastingEquivalents):
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3], dtype=np.int8)
+
+    @pytest.fixture
+    def key(self):
+        return 1
+
+    @pytest.fixture
+    def expected(self):
+        return Series([1, 512, 3], dtype=np.int16)
+
+    @pytest.fixture
+    def warn(self):
+        return FutureWarning
+
+
+@pytest.mark.parametrize("val", [2**33 + 1.0, 2**33 + 1.1, 2**62])
+class TestSmallIntegerSetitemUpcast(SetitemCastingEquivalents):
+    # https://github.com/pandas-dev/pandas/issues/39584#issuecomment-941212124
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3], dtype="i4")
+
+    @pytest.fixture
+    def key(self):
+        return 0
+
+    @pytest.fixture
+    def expected(self, val):
+        if val % 1 != 0:
+            dtype = "f8"
+        else:
+            dtype = "i8"
+        return Series([val, 2, 3], dtype=dtype)
+
+    @pytest.fixture
+    def warn(self):
+        return FutureWarning
+
+
+class CoercionTest(SetitemCastingEquivalents):
+    # Tests ported from tests.indexing.test_coercion
+
+    @pytest.fixture
+    def key(self):
+        return 1
+
+    @pytest.fixture
+    def expected(self, obj, key, val, exp_dtype):
+        vals = list(obj)
+        vals[key] = val
+        return Series(vals, dtype=exp_dtype)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [(np.int32(1), np.int8, None), (np.int16(2**9), np.int16, FutureWarning)],
+)
+class TestCoercionInt8(CoercionTest):
+    # previously test_setitem_series_int8 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3, 4], dtype=np.int8)
+
+
+@pytest.mark.parametrize("val", [1, 1.1, 1 + 1j, True])
+@pytest.mark.parametrize("exp_dtype", [object])
+class TestCoercionObject(CoercionTest):
+    # previously test_setitem_series_object in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series(["a", "b", "c", "d"], dtype=object)
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (1, np.complex128, None),
+        (1.1, np.complex128, None),
+        (1 + 1j, np.complex128, None),
+        (True, object, FutureWarning),
+    ],
+)
+class TestCoercionComplex(CoercionTest):
+    # previously test_setitem_series_complex128 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (1, object, FutureWarning),
+        ("3", object, FutureWarning),
+        (3, object, FutureWarning),
+        (1.1, object, FutureWarning),
+        (1 + 1j, object, FutureWarning),
+        (True, bool, None),
+    ],
+)
+class TestCoercionBool(CoercionTest):
+    # previously test_setitem_series_bool in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([True, False, True, False], dtype=bool)
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (1, np.int64, None),
+        (1.1, np.float64, FutureWarning),
+        (1 + 1j, np.complex128, FutureWarning),
+        (True, object, FutureWarning),
+    ],
+)
+class TestCoercionInt64(CoercionTest):
+    # previously test_setitem_series_int64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1, 2, 3, 4])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (1, np.float64, None),
+        (1.1, np.float64, None),
+        (1 + 1j, np.complex128, FutureWarning),
+        (True, object, FutureWarning),
+    ],
+)
+class TestCoercionFloat64(CoercionTest):
+    # previously test_setitem_series_float64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series([1.1, 2.2, 3.3, 4.4])
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (1, np.float32, None),
+        pytest.param(
+            1.1,
+            np.float32,
+            None,
+            marks=pytest.mark.xfail(
+                reason="np.float32(1.1) ends up as 1.100000023841858, so "
+                "np_can_hold_element raises and we cast to float64",
+            ),
+        ),
+        (1 + 1j, np.complex128, FutureWarning),
+        (True, object, FutureWarning),
+        (np.uint8(2), np.float32, None),
+        (np.uint32(2), np.float32, None),
+        # float32 cannot hold np.iinfo(np.uint32).max exactly
+        # (closest it can hold is 4294967300.0 which off by 5.0), so
+        # we cast to float64
+        (np.uint32(np.iinfo(np.uint32).max), np.float64, FutureWarning),
+        (np.uint64(2), np.float32, None),
+        (np.int64(2), np.float32, None),
+    ],
+)
+class TestCoercionFloat32(CoercionTest):
+    @pytest.fixture
+    def obj(self):
+        return Series([1.1, 2.2, 3.3, 4.4], dtype=np.float32)
+
+    def test_slice_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace):
+        super().test_slice_key(obj, key, expected, warn, val, indexer_sli, is_inplace)
+
+        if type(val) is float:
+            # the xfail would xpass bc test_slice_key short-circuits
+            raise AssertionError("xfail not relevant for this test.")
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (Timestamp("2012-01-01"), "datetime64[ns]", None),
+        (1, object, FutureWarning),
+        ("x", object, FutureWarning),
+    ],
+)
+class TestCoercionDatetime64(CoercionTest):
+    # previously test_setitem_series_datetime64 in tests.indexing.test_coercion
+
+    @pytest.fixture
+    def obj(self):
+        return Series(date_range("2011-01-01", freq="D", periods=4))
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]", None),
+        # pre-2.0, a mis-matched tz would end up casting to object
+        (Timestamp("2012-01-01", tz="US/Pacific"), "datetime64[ns, US/Eastern]", None),
+        (Timestamp("2012-01-01"), object, FutureWarning),
+        (1, object, FutureWarning),
+    ],
+)
+class TestCoercionDatetime64TZ(CoercionTest):
+    # previously test_setitem_series_datetime64tz in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        tz = "US/Eastern"
+        return Series(date_range("2011-01-01", freq="D", periods=4, tz=tz))
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+@pytest.mark.parametrize(
+    "val,exp_dtype,warn",
+    [
+        (Timedelta("12 day"), "timedelta64[ns]", None),
+        (1, object, FutureWarning),
+        ("x", object, FutureWarning),
+    ],
+)
+class TestCoercionTimedelta64(CoercionTest):
+    # previously test_setitem_series_timedelta64 in tests.indexing.test_coercion
+    @pytest.fixture
+    def obj(self):
+        return Series(timedelta_range("1 day", periods=4))
+
+    @pytest.fixture
+    def warn(self):
+        return None
+
+
+@pytest.mark.parametrize(
+    "val", ["foo", Period("2016", freq="Y"), Interval(1, 2, closed="both")]
+)
+@pytest.mark.parametrize("exp_dtype", [object])
+class TestPeriodIntervalCoercion(CoercionTest):
+    # GH#45768
+    @pytest.fixture(
+        params=[
+            period_range("2016-01-01", periods=3, freq="D"),
+            interval_range(1, 5),
+        ]
+    )
+    def obj(self, request):
+        return Series(request.param)
+
+    @pytest.fixture
+    def warn(self):
+        return FutureWarning
+
+
+def test_20643():
+    # closed by GH#45121
+    orig = Series([0, 1, 2], index=["a", "b", "c"])
+
+    expected = Series([0, 2.7, 2], index=["a", "b", "c"])
+
+    ser = orig.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.at["b"] = 2.7
+    tm.assert_series_equal(ser, expected)
+
+    ser = orig.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.loc["b"] = 2.7
+    tm.assert_series_equal(ser, expected)
+
+    ser = orig.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser["b"] = 2.7
+    tm.assert_series_equal(ser, expected)
+
+    ser = orig.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.iat[1] = 2.7
+    tm.assert_series_equal(ser, expected)
+
+    ser = orig.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.iloc[1] = 2.7
+    tm.assert_series_equal(ser, expected)
+
+    orig_df = orig.to_frame("A")
+    expected_df = expected.to_frame("A")
+
+    df = orig_df.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        df.at["b", "A"] = 2.7
+    tm.assert_frame_equal(df, expected_df)
+
+    df = orig_df.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        df.loc["b", "A"] = 2.7
+    tm.assert_frame_equal(df, expected_df)
+
+    df = orig_df.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        df.iloc[1, 0] = 2.7
+    tm.assert_frame_equal(df, expected_df)
+
+    df = orig_df.copy()
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        df.iat[1, 0] = 2.7
+    tm.assert_frame_equal(df, expected_df)
+
+
+def test_20643_comment():
+    # https://github.com/pandas-dev/pandas/issues/20643#issuecomment-431244590
+    # fixed sometime prior to GH#45121
+    orig = Series([0, 1, 2], index=["a", "b", "c"])
+    expected = Series([np.nan, 1, 2], index=["a", "b", "c"])
+
+    ser = orig.copy()
+    ser.iat[0] = None
+    tm.assert_series_equal(ser, expected)
+
+    ser = orig.copy()
+    ser.iloc[0] = None
+    tm.assert_series_equal(ser, expected)
+
+
+def test_15413():
+    # fixed by GH#45121
+    ser = Series([1, 2, 3])
+
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser[ser == 2] += 0.5
+    expected = Series([1, 2.5, 3])
+    tm.assert_series_equal(ser, expected)
+
+    ser = Series([1, 2, 3])
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser[1] += 0.5
+    tm.assert_series_equal(ser, expected)
+
+    ser = Series([1, 2, 3])
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.loc[1] += 0.5
+    tm.assert_series_equal(ser, expected)
+
+    ser = Series([1, 2, 3])
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.iloc[1] += 0.5
+    tm.assert_series_equal(ser, expected)
+
+    ser = Series([1, 2, 3])
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.iat[1] += 0.5
+    tm.assert_series_equal(ser, expected)
+
+    ser = Series([1, 2, 3])
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser.at[1] += 0.5
+    tm.assert_series_equal(ser, expected)
+
+
+def test_32878_int_itemsize():
+    # Fixed by GH#45121
+    arr = np.arange(5).astype("i4")
+    ser = Series(arr)
+    val = np.int64(np.iinfo(np.int64).max)
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser[0] = val
+    expected = Series([val, 1, 2, 3, 4], dtype=np.int64)
+    tm.assert_series_equal(ser, expected)
+
+
+def test_32878_complex_itemsize():
+    arr = np.arange(5).astype("c8")
+    ser = Series(arr)
+    val = np.finfo(np.float64).max
+    val = val.astype("c16")
+
+    # GH#32878 used to coerce val to inf+0.000000e+00j
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        ser[0] = val
+    assert ser[0] == val
+    expected = Series([val, 1, 2, 3, 4], dtype="c16")
+    tm.assert_series_equal(ser, expected)
+
+
+def test_37692(indexer_al):
+    # GH#37692
+    ser = Series([1, 2, 3], index=["a", "b", "c"])
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        indexer_al(ser)["b"] = "test"
+    expected = Series([1, "test", 3], index=["a", "b", "c"], dtype=object)
+    tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_bool_int_float_consistency(indexer_sli):
+    # GH#21513
+    # bool-with-int and bool-with-float both upcast to object
+    #  int-with-float and float-with-int are both non-casting so long
+    #  as the setitem can be done losslessly
+    for dtype in [np.float64, np.int64]:
+        ser = Series(0, index=range(3), dtype=dtype)
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            indexer_sli(ser)[0] = True
+        assert ser.dtype == object
+
+        ser = Series(0, index=range(3), dtype=bool)
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            ser[0] = dtype(1)
+        assert ser.dtype == object
+
+    # 1.0 can be held losslessly, so no casting
+    ser = Series(0, index=range(3), dtype=np.int64)
+    indexer_sli(ser)[0] = np.float64(1.0)
+    assert ser.dtype == np.int64
+
+    # 1 can be held losslessly, so no casting
+    ser = Series(0, index=range(3), dtype=np.float64)
+    indexer_sli(ser)[0] = np.int64(1)
+
+
+def test_setitem_positional_with_casting():
+    # GH#45070 case where in __setitem__ we get a KeyError, then when
+    #  we fallback we *also* get a ValueError if we try to set inplace.
+    ser = Series([1, 2, 3], index=["a", "b", "c"])
+
+    warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        ser[0] = "X"
+    expected = Series(["X", 2, 3], index=["a", "b", "c"], dtype=object)
+    tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_positional_float_into_int_coerces():
+    # Case where we hit a KeyError and then trying to set in-place incorrectly
+    #  casts a float to an int
+    ser = Series([1, 2, 3], index=["a", "b", "c"])
+
+    warn_msg = "Series.__setitem__ treating keys as positions is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=warn_msg):
+        ser[0] = 1.5
+    expected = Series([1.5, 2, 3], index=["a", "b", "c"])
+    tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_int_not_positional():
+    # GH#42215 deprecated falling back to positional on __setitem__ with an
+    #  int not contained in the index; enforced in 2.0
+    ser = Series([1, 2, 3, 4], index=[1.1, 2.1, 3.0, 4.1])
+    assert not ser.index._should_fallback_to_positional
+    # assert not ser.index.astype(object)._should_fallback_to_positional
+
+    # 3.0 is in our index, so post-enforcement behavior is unchanged
+    ser[3] = 10
+    expected = Series([1, 2, 10, 4], index=ser.index)
+    tm.assert_series_equal(ser, expected)
+
+    # pre-enforcement `ser[5] = 5` raised IndexError
+    ser[5] = 5
+    expected = Series([1, 2, 10, 4, 5], index=[1.1, 2.1, 3.0, 4.1, 5.0])
+    tm.assert_series_equal(ser, expected)
+
+    ii = IntervalIndex.from_breaks(range(10))[::2]
+    ser2 = Series(range(len(ii)), index=ii)
+    exp_index = ii.astype(object).append(Index([4]))
+    expected2 = Series([0, 1, 2, 3, 4, 9], index=exp_index)
+    # pre-enforcement `ser2[4] = 9` interpreted 4 as positional
+    ser2[4] = 9
+    tm.assert_series_equal(ser2, expected2)
+
+    mi = MultiIndex.from_product([ser.index, ["A", "B"]])
+    ser3 = Series(range(len(mi)), index=mi)
+    expected3 = ser3.copy()
+    expected3.loc[4] = 99
+    # pre-enforcement `ser3[4] = 99` interpreted 4 as positional
+    ser3[4] = 99
+    tm.assert_series_equal(ser3, expected3)
+
+
+def test_setitem_with_bool_indexer():
+    # GH#42530
+
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    result = df.pop("b")
+    result[[True, False, False]] = 9
+    expected = Series(data=[9, 5, 6], name="b")
+    tm.assert_series_equal(result, expected)
+
+    df.loc[[True, False, False], "a"] = 10
+    expected = DataFrame({"a": [10, 2, 3]})
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("size", range(2, 6))
+@pytest.mark.parametrize(
+    "mask", [[True, False, False, False, False], [True, False], [False]]
+)
+@pytest.mark.parametrize(
+    "item", [2.0, np.nan, np.finfo(float).max, np.finfo(float).min]
+)
+# Test numpy arrays, lists and tuples as the input to be
+# broadcast
+@pytest.mark.parametrize(
+    "box", [lambda x: np.array([x]), lambda x: [x], lambda x: (x,)]
+)
+def test_setitem_bool_indexer_dont_broadcast_length1_values(size, mask, item, box):
+    # GH#44265
+    # see also tests.series.indexing.test_where.test_broadcast
+
+    selection = np.resize(mask, size)
+
+    data = np.arange(size, dtype=float)
+
+    ser = Series(data)
+
+    if selection.sum() != 1:
+        msg = (
+            "cannot set using a list-like indexer with a different "
+            "length than the value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            # GH#44265
+            ser[selection] = box(item)
+    else:
+        # In this corner case setting is equivalent to setting with the unboxed
+        #  item
+        ser[selection] = box(item)
+
+        expected = Series(np.arange(size, dtype=float))
+        expected[selection] = item
+        tm.assert_series_equal(ser, expected)
+
+
+def test_setitem_empty_mask_dont_upcast_dt64():
+    dti = date_range("2016-01-01", periods=3)
+    ser = Series(dti)
+    orig = ser.copy()
+    mask = np.zeros(3, dtype=bool)
+
+    ser[mask] = "foo"
+    assert ser.dtype == dti.dtype  # no-op -> dont upcast
+    tm.assert_series_equal(ser, orig)
+
+    ser.mask(mask, "foo", inplace=True)
+    assert ser.dtype == dti.dtype  # no-op -> dont upcast
+    tm.assert_series_equal(ser, orig)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_take.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_take.py
new file mode 100644
index 0000000000000000000000000000000000000000..43fbae89089665fb2bf589d35db1b3f3041dd018
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_take.py
@@ -0,0 +1,50 @@
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_take_validate_axis():
+    # GH#51022
+    ser = Series([-1, 5, 6, 2, 4])
+
+    msg = "No axis named foo for object type Series"
+    with pytest.raises(ValueError, match=msg):
+        ser.take([1, 2], axis="foo")
+
+
+def test_take():
+    ser = Series([-1, 5, 6, 2, 4])
+
+    actual = ser.take([1, 3, 4])
+    expected = Series([5, 2, 4], index=[1, 3, 4])
+    tm.assert_series_equal(actual, expected)
+
+    actual = ser.take([-1, 3, 4])
+    expected = Series([4, 2, 4], index=[4, 3, 4])
+    tm.assert_series_equal(actual, expected)
+
+    msg = "indices are out-of-bounds"
+    with pytest.raises(IndexError, match=msg):
+        ser.take([1, 10])
+    with pytest.raises(IndexError, match=msg):
+        ser.take([2, 5])
+
+
+def test_take_categorical():
+    # https://github.com/pandas-dev/pandas/issues/20664
+    ser = Series(pd.Categorical(["a", "b", "c"]))
+    result = ser.take([-2, -2, 0])
+    expected = Series(
+        pd.Categorical(["b", "b", "a"], categories=["a", "b", "c"]), index=[1, 1, 0]
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_take_slice_raises():
+    ser = Series([-1, 5, 6, 2, 4])
+
+    msg = "Series.take requires a sequence of integers, not slice"
+    with pytest.raises(TypeError, match=msg):
+        ser.take(slice(0, 3, 1))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_where.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_where.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e002420dadfc14022dd5a5dc02ee19a89fe1a44
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_where.py
@@ -0,0 +1,473 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer
+
+import pandas as pd
+from pandas import (
+    Series,
+    Timestamp,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+
+
+def test_where_unsafe_int(any_signed_int_numpy_dtype):
+    s = Series(np.arange(10), dtype=any_signed_int_numpy_dtype)
+    mask = s < 5
+
+    s[mask] = range(2, 7)
+    expected = Series(
+        list(range(2, 7)) + list(range(5, 10)),
+        dtype=any_signed_int_numpy_dtype,
+    )
+
+    tm.assert_series_equal(s, expected)
+
+
+def test_where_unsafe_float(float_numpy_dtype):
+    s = Series(np.arange(10), dtype=float_numpy_dtype)
+    mask = s < 5
+
+    s[mask] = range(2, 7)
+    data = list(range(2, 7)) + list(range(5, 10))
+    expected = Series(data, dtype=float_numpy_dtype)
+
+    tm.assert_series_equal(s, expected)
+
+
+@pytest.mark.parametrize(
+    "dtype,expected_dtype",
+    [
+        (np.int8, np.float64),
+        (np.int16, np.float64),
+        (np.int32, np.float64),
+        (np.int64, np.float64),
+        (np.float32, np.float32),
+        (np.float64, np.float64),
+    ],
+)
+def test_where_unsafe_upcast(dtype, expected_dtype):
+    # see gh-9743
+    s = Series(np.arange(10), dtype=dtype)
+    values = [2.5, 3.5, 4.5, 5.5, 6.5]
+    mask = s < 5
+    expected = Series(values + list(range(5, 10)), dtype=expected_dtype)
+    warn = (
+        None
+        if np.dtype(dtype).kind == np.dtype(expected_dtype).kind == "f"
+        else FutureWarning
+    )
+    with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        s[mask] = values
+    tm.assert_series_equal(s, expected)
+
+
+def test_where_unsafe():
+    # see gh-9731
+    s = Series(np.arange(10), dtype="int64")
+    values = [2.5, 3.5, 4.5, 5.5]
+
+    mask = s > 5
+    expected = Series(list(range(6)) + values, dtype="float64")
+
+    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        s[mask] = values
+    tm.assert_series_equal(s, expected)
+
+    # see gh-3235
+    s = Series(np.arange(10), dtype="int64")
+    mask = s < 5
+    s[mask] = range(2, 7)
+    expected = Series(list(range(2, 7)) + list(range(5, 10)), dtype="int64")
+    tm.assert_series_equal(s, expected)
+    assert s.dtype == expected.dtype
+
+    s = Series(np.arange(10), dtype="int64")
+    mask = s > 5
+    s[mask] = [0] * 4
+    expected = Series([0, 1, 2, 3, 4, 5] + [0] * 4, dtype="int64")
+    tm.assert_series_equal(s, expected)
+
+    s = Series(np.arange(10))
+    mask = s > 5
+
+    msg = "cannot set using a list-like indexer with a different length than the value"
+    with pytest.raises(ValueError, match=msg):
+        s[mask] = [5, 4, 3, 2, 1]
+
+    with pytest.raises(ValueError, match=msg):
+        s[mask] = [0] * 5
+
+    # dtype changes
+    s = Series([1, 2, 3, 4])
+    result = s.where(s > 2, np.nan)
+    expected = Series([np.nan, np.nan, 3, 4])
+    tm.assert_series_equal(result, expected)
+
+    # GH 4667
+    # setting with None changes dtype
+    s = Series(range(10)).astype(float)
+    s[8] = None
+    result = s[8]
+    assert isna(result)
+
+    s = Series(range(10)).astype(float)
+    s[s > 8] = None
+    result = s[isna(s)]
+    expected = Series(np.nan, index=[9])
+    tm.assert_series_equal(result, expected)
+
+
+def test_where():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.where(cond).dropna()
+    rs2 = s[cond]
+    tm.assert_series_equal(rs, rs2)
+
+    rs = s.where(cond, -s)
+    tm.assert_series_equal(rs, s.abs())
+
+    rs = s.where(cond)
+    assert s.shape == rs.shape
+    assert rs is not s
+
+    # test alignment
+    cond = Series([True, False, False, True, False], index=s.index)
+    s2 = -(s.abs())
+
+    expected = s2[cond].reindex(s2.index[:3]).reindex(s2.index)
+    rs = s2.where(cond[:3])
+    tm.assert_series_equal(rs, expected)
+
+    expected = s2.abs()
+    expected.iloc[0] = s2[0]
+    rs = s2.where(cond[:3], -s2)
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_error():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.where(1)
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond[:3].values, -s)
+
+    # GH 2745
+    s = Series([1, 2])
+    s[[True, False]] = [0, 1]
+    expected = Series([0, 2])
+    tm.assert_series_equal(s, expected)
+
+    # failures
+    msg = "cannot set using a list-like indexer with a different length than the value"
+    with pytest.raises(ValueError, match=msg):
+        s[[True, False]] = [0, 2, 3]
+
+    with pytest.raises(ValueError, match=msg):
+        s[[True, False]] = []
+
+
+@pytest.mark.parametrize("klass", [list, tuple, np.array, Series])
+def test_where_array_like(klass):
+    # see gh-15414
+    s = Series([1, 2, 3])
+    cond = [False, True, True]
+    expected = Series([np.nan, 2, 3])
+
+    result = s.where(klass(cond))
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "cond",
+    [
+        [1, 0, 1],
+        Series([2, 5, 7]),
+        ["True", "False", "True"],
+        [Timestamp("2017-01-01"), pd.NaT, Timestamp("2017-01-02")],
+    ],
+)
+def test_where_invalid_input(cond):
+    # see gh-15414: only boolean arrays accepted
+    s = Series([1, 2, 3])
+    msg = "Boolean array expected for the condition"
+
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    msg = "Array conditional must be same shape as self"
+    with pytest.raises(ValueError, match=msg):
+        s.where([True])
+
+
+def test_where_ndframe_align():
+    msg = "Array conditional must be same shape as self"
+    s = Series([1, 2, 3])
+
+    cond = [True]
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    expected = Series([1, np.nan, np.nan])
+
+    out = s.where(Series(cond))
+    tm.assert_series_equal(out, expected)
+
+    cond = np.array([False, True, False, True])
+    with pytest.raises(ValueError, match=msg):
+        s.where(cond)
+
+    expected = Series([np.nan, 2, np.nan])
+
+    out = s.where(Series(cond))
+    tm.assert_series_equal(out, expected)
+
+
+def test_where_setitem_invalid():
+    # GH 2702
+    # make sure correct exceptions are raised on invalid list assignment
+
+    msg = (
+        lambda x: f"cannot set using a {x} indexer with a "
+        "different length than the value"
+    )
+    # slice
+    s = Series(list("abc"))
+
+    with pytest.raises(ValueError, match=msg("slice")):
+        s[0:3] = list(range(27))
+
+    s[0:3] = list(range(3))
+    expected = Series([0, 1, 2])
+    tm.assert_series_equal(s.astype(np.int64), expected)
+
+    # slice with step
+    s = Series(list("abcdef"))
+
+    with pytest.raises(ValueError, match=msg("slice")):
+        s[0:4:2] = list(range(27))
+
+    s = Series(list("abcdef"))
+    s[0:4:2] = list(range(2))
+    expected = Series([0, "b", 1, "d", "e", "f"])
+    tm.assert_series_equal(s, expected)
+
+    # neg slices
+    s = Series(list("abcdef"))
+
+    with pytest.raises(ValueError, match=msg("slice")):
+        s[:-1] = list(range(27))
+
+    s[-3:-1] = list(range(2))
+    expected = Series(["a", "b", "c", 0, 1, "f"])
+    tm.assert_series_equal(s, expected)
+
+    # list
+    s = Series(list("abc"))
+
+    with pytest.raises(ValueError, match=msg("list-like")):
+        s[[0, 1, 2]] = list(range(27))
+
+    s = Series(list("abc"))
+
+    with pytest.raises(ValueError, match=msg("list-like")):
+        s[[0, 1, 2]] = list(range(2))
+
+    # scalar
+    s = Series(list("abc"))
+    s[0] = list(range(10))
+    expected = Series([list(range(10)), "b", "c"])
+    tm.assert_series_equal(s, expected)
+
+
+@pytest.mark.parametrize("size", range(2, 6))
+@pytest.mark.parametrize(
+    "mask", [[True, False, False, False, False], [True, False], [False]]
+)
+@pytest.mark.parametrize(
+    "item", [2.0, np.nan, np.finfo(float).max, np.finfo(float).min]
+)
+# Test numpy arrays, lists and tuples as the input to be
+# broadcast
+@pytest.mark.parametrize(
+    "box", [lambda x: np.array([x]), lambda x: [x], lambda x: (x,)]
+)
+def test_broadcast(size, mask, item, box):
+    # GH#8801, GH#4195
+    selection = np.resize(mask, size)
+
+    data = np.arange(size, dtype=float)
+
+    # Construct the expected series by taking the source
+    # data or item based on the selection
+    expected = Series(
+        [item if use_item else data[i] for i, use_item in enumerate(selection)]
+    )
+
+    s = Series(data)
+
+    s[selection] = item
+    tm.assert_series_equal(s, expected)
+
+    s = Series(data)
+    result = s.where(~selection, box(item))
+    tm.assert_series_equal(result, expected)
+
+    s = Series(data)
+    result = s.mask(selection, box(item))
+    tm.assert_series_equal(result, expected)
+
+
+def test_where_inplace():
+    s = Series(np.random.default_rng(2).standard_normal(5))
+    cond = s > 0
+
+    rs = s.copy()
+
+    rs.where(cond, inplace=True)
+    tm.assert_series_equal(rs.dropna(), s[cond])
+    tm.assert_series_equal(rs, s.where(cond))
+
+    rs = s.copy()
+    rs.where(cond, -s, inplace=True)
+    tm.assert_series_equal(rs, s.where(cond, -s))
+
+
+def test_where_dups():
+    # GH 4550
+    # where crashes with dups in index
+    s1 = Series(list(range(3)))
+    s2 = Series(list(range(3)))
+    comb = pd.concat([s1, s2])
+    result = comb.where(comb < 2)
+    expected = Series([0, 1, np.nan, 0, 1, np.nan], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(result, expected)
+
+    # GH 4548
+    # inplace updating not working with dups
+    comb[comb < 1] = 5
+    expected = Series([5, 1, 2, 5, 1, 2], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(comb, expected)
+
+    comb[comb < 2] += 10
+    expected = Series([5, 11, 2, 5, 11, 2], index=[0, 1, 2, 0, 1, 2])
+    tm.assert_series_equal(comb, expected)
+
+
+def test_where_numeric_with_string():
+    # GH 9280
+    s = Series([1, 2, 3])
+    w = s.where(s > 1, "X")
+
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+    w = s.where(s > 1, ["X", "Y", "Z"])
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+    w = s.where(s > 1, np.array(["X", "Y", "Z"]))
+    assert not is_integer(w[0])
+    assert is_integer(w[1])
+    assert is_integer(w[2])
+    assert isinstance(w[0], str)
+    assert w.dtype == "object"
+
+
+@pytest.mark.parametrize("dtype", ["timedelta64[ns]", "datetime64[ns]"])
+def test_where_datetimelike_coerce(dtype):
+    ser = Series([1, 2], dtype=dtype)
+    expected = Series([10, 10])
+    mask = np.array([False, False])
+
+    rs = ser.where(mask, [10, 10])
+    tm.assert_series_equal(rs, expected)
+
+    rs = ser.where(mask, 10)
+    tm.assert_series_equal(rs, expected)
+
+    rs = ser.where(mask, 10.0)
+    tm.assert_series_equal(rs, expected)
+
+    rs = ser.where(mask, [10.0, 10.0])
+    tm.assert_series_equal(rs, expected)
+
+    rs = ser.where(mask, [10.0, np.nan])
+    expected = Series([10, np.nan], dtype="object")
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_datetimetz():
+    # GH 15701
+    timestamps = ["2016-12-31 12:00:04+00:00", "2016-12-31 12:00:04.010000+00:00"]
+    ser = Series([Timestamp(t) for t in timestamps], dtype="datetime64[ns, UTC]")
+    rs = ser.where(Series([False, True]))
+    expected = Series([pd.NaT, ser[1]], dtype="datetime64[ns, UTC]")
+    tm.assert_series_equal(rs, expected)
+
+
+def test_where_sparse():
+    # GH#17198 make sure we dont get an AttributeError for sp_index
+    ser = Series(pd.arrays.SparseArray([1, 2]))
+    result = ser.where(ser >= 2, 0)
+    expected = Series(pd.arrays.SparseArray([0, 2]))
+    tm.assert_series_equal(result, expected)
+
+
+def test_where_empty_series_and_empty_cond_having_non_bool_dtypes():
+    # https://github.com/pandas-dev/pandas/issues/34592
+    ser = Series([], dtype=float)
+    result = ser.where([])
+    tm.assert_series_equal(result, ser)
+
+
+def test_where_categorical(frame_or_series):
+    # https://github.com/pandas-dev/pandas/issues/18888
+    exp = frame_or_series(
+        pd.Categorical(["A", "A", "B", "B", np.nan], categories=["A", "B", "C"]),
+        dtype="category",
+    )
+    df = frame_or_series(["A", "A", "B", "B", "C"], dtype="category")
+    res = df.where(df != "C")
+    tm.assert_equal(exp, res)
+
+
+def test_where_datetimelike_categorical(tz_naive_fixture):
+    # GH#37682
+    tz = tz_naive_fixture
+
+    dr = date_range("2001-01-01", periods=3, tz=tz)._with_freq(None)
+    lvals = pd.DatetimeIndex([dr[0], dr[1], pd.NaT])
+    rvals = pd.Categorical([dr[0], pd.NaT, dr[2]])
+
+    mask = np.array([True, True, False])
+
+    # DatetimeIndex.where
+    res = lvals.where(mask, rvals)
+    tm.assert_index_equal(res, dr)
+
+    # DatetimeArray.where
+    res = lvals._data._where(mask, rvals)
+    tm.assert_datetime_array_equal(res, dr._data)
+
+    # Series.where
+    res = Series(lvals).where(mask, rvals)
+    tm.assert_series_equal(res, Series(dr))
+
+    # DataFrame.where
+    res = pd.DataFrame(lvals).where(mask[:, None], pd.DataFrame(rvals))
+
+    tm.assert_frame_equal(res, pd.DataFrame(dr))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_xs.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_xs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a67f3ec708f24a97dab544bb5cf859dc54659215
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/indexing/test_xs.py
@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    MultiIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def test_xs_datetimelike_wrapping():
+    # GH#31630 a case where we shouldn't wrap datetime64 in Timestamp
+    arr = date_range("2016-01-01", periods=3)._data._ndarray
+
+    ser = Series(arr, dtype=object)
+    for i in range(len(ser)):
+        ser.iloc[i] = arr[i]
+    assert ser.dtype == object
+    assert isinstance(ser[0], np.datetime64)
+
+    result = ser.xs(0)
+    assert isinstance(result, np.datetime64)
+
+
+class TestXSWithMultiIndex:
+    def test_xs_level_series(self, multiindex_dataframe_random_data):
+        df = multiindex_dataframe_random_data
+        ser = df["A"]
+        expected = ser[:, "two"]
+        result = df.xs("two", level=1)["A"]
+        tm.assert_series_equal(result, expected)
+
+    def test_series_getitem_multiindex_xs_by_label(self):
+        # GH#5684
+        idx = MultiIndex.from_tuples(
+            [("a", "one"), ("a", "two"), ("b", "one"), ("b", "two")]
+        )
+        ser = Series([1, 2, 3, 4], index=idx)
+        return_value = ser.index.set_names(["L1", "L2"], inplace=True)
+        assert return_value is None
+        expected = Series([1, 3], index=["a", "b"])
+        return_value = expected.index.set_names(["L1"], inplace=True)
+        assert return_value is None
+
+        result = ser.xs("one", level="L2")
+        tm.assert_series_equal(result, expected)
+
+    def test_series_getitem_multiindex_xs(self):
+        # GH#6258
+        dt = list(date_range("20130903", periods=3))
+        idx = MultiIndex.from_product([list("AB"), dt])
+        ser = Series([1, 3, 4, 1, 3, 4], index=idx)
+        expected = Series([1, 1], index=list("AB"))
+
+        result = ser.xs("20130903", level=1)
+        tm.assert_series_equal(result, expected)
+
+    def test_series_xs_droplevel_false(self):
+        # GH: 19056
+        mi = MultiIndex.from_tuples(
+            [("a", "x"), ("a", "y"), ("b", "x")], names=["level1", "level2"]
+        )
+        ser = Series([1, 1, 1], index=mi)
+        result = ser.xs("a", axis=0, drop_level=False)
+        expected = Series(
+            [1, 1],
+            index=MultiIndex.from_tuples(
+                [("a", "x"), ("a", "y")], names=["level1", "level2"]
+            ),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_xs_key_as_list(self):
+        # GH#41760
+        mi = MultiIndex.from_tuples([("a", "x")], names=["level1", "level2"])
+        ser = Series([1], index=mi)
+        with pytest.raises(TypeError, match="list keys are not supported"):
+            ser.xs(["a", "x"], axis=0, drop_level=False)
+
+        with pytest.raises(TypeError, match="list keys are not supported"):
+            ser.xs(["a"], axis=0, drop_level=False)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__init__.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcb0d30f405e2079a1ff21d838f52cd5f659fd93
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__init__.py
@@ -0,0 +1,7 @@
+"""
+Test files dedicated to individual (stand-alone) Series methods
+
+Ideally these files/tests should correspond 1-to-1 with tests.frame.methods
+
+These may also present opportunities for sharing/de-duplicating test code.
+"""
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60520b49c716b83f710ddd3a2ef5e7f872770cb5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..904c60341ae1b3fb46b257dc89747d265b744998
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_add_prefix_suffix.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_align.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_align.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b42e19592ca2d7eeb04db493b93bf44b4c5dc352
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_align.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_argsort.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_argsort.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5202f0e84aa0b3f9a5f24c2ffb48c6704cdb0fa9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_argsort.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_asof.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_asof.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a1c4758588c60e5cd2e48d4b75a2f5b675dc8e0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_asof.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_astype.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_astype.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7284c34ccda8445823877350bab77e4495224374
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_astype.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_autocorr.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_autocorr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..999d9f8bf3afea0aa26d914bb1146e3b31665de4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_autocorr.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_between.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_between.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd9f2f9dd83be441b9b7aa1fee5aed0591eff567
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_between.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_clip.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_clip.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09221f3670d50eca9946ae59afb8bf7700775866
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_clip.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_combine.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_combine.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e6531f7a1a8a7ac03253e77ae9fd16ba3ca6f95
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_combine.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_combine_first.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_combine_first.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d09dbb759ff1f5c0d8514a4c4f2a1d24fcf8166c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_combine_first.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_compare.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_compare.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b12af556f94a91a69234716081036682479d1923
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_compare.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_convert_dtypes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_convert_dtypes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..faa5cbcaabe28d62bb2da6897e335b35aff0ac3e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_convert_dtypes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_copy.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_copy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a900315ce6fad0b1144489141d8474ecea6bb8b4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_copy.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_count.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_count.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43943ac06701af9c9f0d3bc07ef30ce8af6167c4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_count.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_cov_corr.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_cov_corr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f10c99ff5d0592b067b0257b35cd192d8d22ebc4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_cov_corr.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_describe.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_describe.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f24fef4b16a1325a9d7985ec241390a82ea19bc3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_describe.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_diff.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d897af42cc2f96b26fd35f920d34b832869502c0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_diff.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_drop.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_drop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f3aba3b9a3cc238db272d8d792e1f96d982d2253
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_drop.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_drop_duplicates.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_drop_duplicates.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..47499917d6b0b9625619065a1e7206a3750cf069
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_drop_duplicates.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_dropna.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_dropna.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f41e5a5fb08408369bb78229860cc645fd39e4a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_dropna.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_dtypes.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_dtypes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a29417f75baf3f8ae6247902454d4fdab717edde
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_dtypes.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_duplicated.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_duplicated.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..365910c93f129f051d87adf91e13ff3a800628d5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_duplicated.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_equals.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_equals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eff3767cb9f0dcf73db1ba4448281bdd71d8e1eb
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_equals.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_explode.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_explode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8c6d42bd61c995294792ba1dbf20a950fc9e40e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_explode.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_fillna.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_fillna.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c09c15465be28f84dd390ff5e6815fc7c4218bfc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_fillna.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_get_numeric_data.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_get_numeric_data.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7412dc28f41059b9c21422a0c326af768ec42af
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_get_numeric_data.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_head_tail.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_head_tail.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bae6b68506cedb48f442901ff2d35fb7b770a811
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_head_tail.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_infer_objects.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_infer_objects.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9b9efee270848a055a082ff9f5d6ab7c86fa07a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_infer_objects.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_interpolate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_interpolate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3f1388c40e2de15665d25e72ba90e6329476c3b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_interpolate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_is_monotonic.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_is_monotonic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6be4ed7b499d89624175ad3cc35851c6cb755fe3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_is_monotonic.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_is_unique.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_is_unique.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..048092aca20077a32205c8067c693895e6927311
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_is_unique.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_isin.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_isin.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ac29ffac568c556b1604dd7c47613af1ef1f1ad
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_isin.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_isna.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_isna.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb282dd06270fe4a887de296443df3ccfb6619fc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_isna.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_item.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_item.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12c6f813fe1553b44bc44d5451325b13a196e9fc
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_item.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_map.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_map.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6127961fb414eb2d573b4d5dd2db69f9e4b81c0b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_map.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_matmul.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_matmul.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2fb1db6c3236930c058f1cbd6c2f0888408d8e7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_matmul.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_nlargest.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_nlargest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2463cdbc7cc1348d9c8424d3c442bd3a9bf19480
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_nlargest.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_nunique.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_nunique.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d2f1a44dfc0f9bd7f54b2eb61f8f19fa967effb
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_nunique.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_pct_change.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_pct_change.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..982e984175327f0db60b10119bd894fce26741cf
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_pct_change.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_pop.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_pop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..948756f339f6297573b94200c2ba3788353fc1d8
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_pop.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_quantile.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_quantile.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1a7772076a3648e31ea3d3161aae2c98cd09f6e2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_quantile.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rank.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rank.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b272aa14e939e1864ac2840bb55c503a3729193
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rank.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reindex.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reindex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03adbc946eb9720e7760c4008df601b1bc0f0634
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reindex.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reindex_like.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reindex_like.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a60f99b209b1ebacd1fc9d2b3c7b10255505289b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reindex_like.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rename.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rename.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fca701b988d4fab0455d712271ba5e3bf3a13e97
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rename.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rename_axis.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rename_axis.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f39bc9eddd7cadd169384254a8052b9a83331c79
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_rename_axis.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_repeat.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_repeat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..843b618a026ee3461d997f0323fc1ffdf8785ed8
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_repeat.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_replace.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_replace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ca3c2fa3c67bec674a5683371dec439dade6171
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_replace.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reset_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reset_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b20f71f17063cb07834df8e115e9a6ffc4db2285
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_reset_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_round.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_round.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70fe738ed09e1b29635e59f703b3302be7fadc2a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_round.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_searchsorted.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_searchsorted.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..92a9b0a411586b68fecf251d835b1609dcde7757
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_searchsorted.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_set_name.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_set_name.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..82bfb0d7615ad2c4a9cb265edb0602229f308a55
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_set_name.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_size.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_size.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c18f8440e92950e75bcf3ae4f1b20e0e190aca26
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_size.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_sort_index.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_sort_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe828d91bc1234bdfe7acccd6c99e9a43ecd8df7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_sort_index.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_sort_values.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_sort_values.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eaf439a69bf15f4838096e9e4e681a5ac25b4144
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_sort_values.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_csv.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_csv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59a0b58e9da2623df6ba62bd2b31bb1dd398f7c9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_csv.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_dict.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_dict.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea0fc5b9a4943befa3b80af2ccca13fb7ea6d8b6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_dict.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_frame.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_frame.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f60f76734df79009a3daac659d9d27de6f794ae
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_frame.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_numpy.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ffa7b2fa3a8b8da046faf5b8c72d9b8d114c23d3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_to_numpy.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_tolist.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_tolist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49e468a266d37240f13dc2fa1c78a8f1fc3382a2
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_tolist.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_truncate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_truncate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..560d0e6feb11d8bf9c9cfc0ff310d6d19879e5fe
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_truncate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_tz_localize.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_tz_localize.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b08ed243e68f43e90ece82ccea22cb1d3abd8721
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_tz_localize.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_unique.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_unique.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67c6ed87a4f7dfdab8cc75c1179c94ee764fe336
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_unique.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_unstack.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_unstack.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5ca82b9320693125b14a5da127d99c9f4e38786
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_unstack.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_update.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_update.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19cd135dbd6fcc9afebf97bd96662f8b84073cb9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_update.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_value_counts.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_value_counts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e122a5039d1ebe613168cc41f4a5b9fe4ce0eb8
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_value_counts.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_values.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_values.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23803a89399b98efd6be6562123661f0a67d0d93
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_values.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_view.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_view.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..416327481340c70a86434b05da07915fbe251bee
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/__pycache__/test_view.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_add_prefix_suffix.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_add_prefix_suffix.py
new file mode 100644
index 0000000000000000000000000000000000000000..289a56b98b7e123fb1c1edf5cc9ff41369d51122
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_add_prefix_suffix.py
@@ -0,0 +1,41 @@
+import pytest
+
+from pandas import Index
+import pandas._testing as tm
+
+
+def test_add_prefix_suffix(string_series):
+    with_prefix = string_series.add_prefix("foo#")
+    expected = Index([f"foo#{c}" for c in string_series.index])
+    tm.assert_index_equal(with_prefix.index, expected)
+
+    with_suffix = string_series.add_suffix("#foo")
+    expected = Index([f"{c}#foo" for c in string_series.index])
+    tm.assert_index_equal(with_suffix.index, expected)
+
+    with_pct_prefix = string_series.add_prefix("%")
+    expected = Index([f"%{c}" for c in string_series.index])
+    tm.assert_index_equal(with_pct_prefix.index, expected)
+
+    with_pct_suffix = string_series.add_suffix("%")
+    expected = Index([f"{c}%" for c in string_series.index])
+    tm.assert_index_equal(with_pct_suffix.index, expected)
+
+
+def test_add_prefix_suffix_axis(string_series):
+    # GH 47819
+    with_prefix = string_series.add_prefix("foo#", axis=0)
+    expected = Index([f"foo#{c}" for c in string_series.index])
+    tm.assert_index_equal(with_prefix.index, expected)
+
+    with_pct_suffix = string_series.add_suffix("#foo", axis=0)
+    expected = Index([f"{c}#foo" for c in string_series.index])
+    tm.assert_index_equal(with_pct_suffix.index, expected)
+
+
+def test_add_prefix_suffix_invalid_axis(string_series):
+    with pytest.raises(ValueError, match="No axis named 1 for object type Series"):
+        string_series.add_prefix("foo#", axis=1)
+
+    with pytest.raises(ValueError, match="No axis named 1 for object type Series"):
+        string_series.add_suffix("foo#", axis=1)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_align.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_align.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1b3dd4888ef534585fdb9a4e165642cf89edd11
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_align.py
@@ -0,0 +1,249 @@
+from datetime import timezone
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "first_slice,second_slice",
+    [
+        [[2, None], [None, -5]],
+        [[None, 0], [None, -5]],
+        [[None, -5], [None, 0]],
+        [[None, 0], [None, 0]],
+    ],
+)
+@pytest.mark.parametrize("fill", [None, -1])
+def test_align(datetime_series, first_slice, second_slice, join_type, fill):
+    a = datetime_series[slice(*first_slice)]
+    b = datetime_series[slice(*second_slice)]
+
+    aa, ab = a.align(b, join=join_type, fill_value=fill)
+
+    join_index = a.index.join(b.index, how=join_type)
+    if fill is not None:
+        diff_a = aa.index.difference(join_index)
+        diff_b = ab.index.difference(join_index)
+        if len(diff_a) > 0:
+            assert (aa.reindex(diff_a) == fill).all()
+        if len(diff_b) > 0:
+            assert (ab.reindex(diff_b) == fill).all()
+
+    ea = a.reindex(join_index)
+    eb = b.reindex(join_index)
+
+    if fill is not None:
+        ea = ea.fillna(fill)
+        eb = eb.fillna(fill)
+
+    tm.assert_series_equal(aa, ea)
+    tm.assert_series_equal(ab, eb)
+    assert aa.name == "ts"
+    assert ea.name == "ts"
+    assert ab.name == "ts"
+    assert eb.name == "ts"
+
+
+@pytest.mark.parametrize(
+    "first_slice,second_slice",
+    [
+        [[2, None], [None, -5]],
+        [[None, 0], [None, -5]],
+        [[None, -5], [None, 0]],
+        [[None, 0], [None, 0]],
+    ],
+)
+@pytest.mark.parametrize("method", ["pad", "bfill"])
+@pytest.mark.parametrize("limit", [None, 1])
+def test_align_fill_method(
+    datetime_series, first_slice, second_slice, join_type, method, limit
+):
+    a = datetime_series[slice(*first_slice)]
+    b = datetime_series[slice(*second_slice)]
+
+    msg = (
+        "The 'method', 'limit', and 'fill_axis' keywords in Series.align "
+        "are deprecated"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        aa, ab = a.align(b, join=join_type, method=method, limit=limit)
+
+    join_index = a.index.join(b.index, how=join_type)
+    ea = a.reindex(join_index)
+    eb = b.reindex(join_index)
+
+    msg2 = "Series.fillna with 'method' is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg2):
+        ea = ea.fillna(method=method, limit=limit)
+        eb = eb.fillna(method=method, limit=limit)
+
+    tm.assert_series_equal(aa, ea)
+    tm.assert_series_equal(ab, eb)
+
+
+def test_align_nocopy(datetime_series, using_copy_on_write):
+    b = datetime_series[:5].copy()
+
+    # do copy
+    a = datetime_series.copy()
+    ra, _ = a.align(b, join="left")
+    ra[:5] = 5
+    assert not (a[:5] == 5).any()
+
+    # do not copy
+    a = datetime_series.copy()
+    ra, _ = a.align(b, join="left", copy=False)
+    ra[:5] = 5
+    if using_copy_on_write:
+        assert not (a[:5] == 5).any()
+    else:
+        assert (a[:5] == 5).all()
+
+    # do copy
+    a = datetime_series.copy()
+    b = datetime_series[:5].copy()
+    _, rb = a.align(b, join="right")
+    rb[:3] = 5
+    assert not (b[:3] == 5).any()
+
+    # do not copy
+    a = datetime_series.copy()
+    b = datetime_series[:5].copy()
+    _, rb = a.align(b, join="right", copy=False)
+    rb[:2] = 5
+    if using_copy_on_write:
+        assert not (b[:2] == 5).any()
+    else:
+        assert (b[:2] == 5).all()
+
+
+def test_align_same_index(datetime_series, using_copy_on_write):
+    a, b = datetime_series.align(datetime_series, copy=False)
+    if not using_copy_on_write:
+        assert a.index is datetime_series.index
+        assert b.index is datetime_series.index
+    else:
+        assert a.index.is_(datetime_series.index)
+        assert b.index.is_(datetime_series.index)
+
+    a, b = datetime_series.align(datetime_series, copy=True)
+    assert a.index is not datetime_series.index
+    assert b.index is not datetime_series.index
+    assert a.index.is_(datetime_series.index)
+    assert b.index.is_(datetime_series.index)
+
+
+def test_align_multiindex():
+    # GH 10665
+
+    midx = pd.MultiIndex.from_product(
+        [range(2), range(3), range(2)], names=("a", "b", "c")
+    )
+    idx = pd.Index(range(2), name="b")
+    s1 = Series(np.arange(12, dtype="int64"), index=midx)
+    s2 = Series(np.arange(2, dtype="int64"), index=idx)
+
+    # these must be the same results (but flipped)
+    res1l, res1r = s1.align(s2, join="left")
+    res2l, res2r = s2.align(s1, join="right")
+
+    expl = s1
+    tm.assert_series_equal(expl, res1l)
+    tm.assert_series_equal(expl, res2r)
+    expr = Series([0, 0, 1, 1, np.nan, np.nan] * 2, index=midx)
+    tm.assert_series_equal(expr, res1r)
+    tm.assert_series_equal(expr, res2l)
+
+    res1l, res1r = s1.align(s2, join="right")
+    res2l, res2r = s2.align(s1, join="left")
+
+    exp_idx = pd.MultiIndex.from_product(
+        [range(2), range(2), range(2)], names=("a", "b", "c")
+    )
+    expl = Series([0, 1, 2, 3, 6, 7, 8, 9], index=exp_idx)
+    tm.assert_series_equal(expl, res1l)
+    tm.assert_series_equal(expl, res2r)
+    expr = Series([0, 0, 1, 1] * 2, index=exp_idx)
+    tm.assert_series_equal(expr, res1r)
+    tm.assert_series_equal(expr, res2l)
+
+
+@pytest.mark.parametrize("method", ["backfill", "bfill", "pad", "ffill", None])
+def test_align_with_dataframe_method(method):
+    # GH31788
+    ser = Series(range(3), index=range(3))
+    df = pd.DataFrame(0.0, index=range(3), columns=range(3))
+
+    msg = (
+        "The 'method', 'limit', and 'fill_axis' keywords in Series.align "
+        "are deprecated"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result_ser, result_df = ser.align(df, method=method)
+    tm.assert_series_equal(result_ser, ser)
+    tm.assert_frame_equal(result_df, df)
+
+
+def test_align_dt64tzindex_mismatched_tzs():
+    idx1 = date_range("2001", periods=5, freq="H", tz="US/Eastern")
+    ser = Series(np.random.default_rng(2).standard_normal(len(idx1)), index=idx1)
+    ser_central = ser.tz_convert("US/Central")
+    # different timezones convert to UTC
+
+    new1, new2 = ser.align(ser_central)
+    assert new1.index.tz is timezone.utc
+    assert new2.index.tz is timezone.utc
+
+
+def test_align_periodindex(join_type):
+    rng = period_range("1/1/2000", "1/1/2010", freq="A")
+    ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+    # TODO: assert something?
+    ts.align(ts[::2], join=join_type)
+
+
+def test_align_left_fewer_levels():
+    # GH#45224
+    left = Series([2], index=pd.MultiIndex.from_tuples([(1, 3)], names=["a", "c"]))
+    right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"])
+    )
+    result_left, result_right = left.align(right)
+
+    expected_right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 3, 2)], names=["a", "c", "b"])
+    )
+    expected_left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 3, 2)], names=["a", "c", "b"])
+    )
+    tm.assert_series_equal(result_left, expected_left)
+    tm.assert_series_equal(result_right, expected_right)
+
+
+def test_align_left_different_named_levels():
+    # GH#45224
+    left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 4, 3)], names=["a", "d", "c"])
+    )
+    right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 2, 3)], names=["a", "b", "c"])
+    )
+    result_left, result_right = left.align(right)
+
+    expected_left = Series(
+        [2], index=pd.MultiIndex.from_tuples([(1, 3, 4, 2)], names=["a", "c", "d", "b"])
+    )
+    expected_right = Series(
+        [1], index=pd.MultiIndex.from_tuples([(1, 3, 4, 2)], names=["a", "c", "d", "b"])
+    )
+    tm.assert_series_equal(result_left, expected_left)
+    tm.assert_series_equal(result_right, expected_right)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_argsort.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_argsort.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bcf42aad1db436dd87543b8e30ae18597a83dd1
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_argsort.py
@@ -0,0 +1,81 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    Timestamp,
+    isna,
+)
+import pandas._testing as tm
+
+
+class TestSeriesArgsort:
+    def test_argsort_axis(self):
+        # GH#54257
+        ser = Series(range(3))
+
+        msg = "No axis named 2 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser.argsort(axis=2)
+
+    def test_argsort_numpy(self, datetime_series):
+        ser = datetime_series
+
+        res = np.argsort(ser).values
+        expected = np.argsort(np.array(ser))
+        tm.assert_numpy_array_equal(res, expected)
+
+        # with missing values
+        ts = ser.copy()
+        ts[::2] = np.nan
+
+        msg = "The behavior of Series.argsort in the presence of NA values"
+        with tm.assert_produces_warning(
+            FutureWarning, match=msg, check_stacklevel=False
+        ):
+            result = np.argsort(ts)[1::2]
+        expected = np.argsort(np.array(ts.dropna()))
+
+        tm.assert_numpy_array_equal(result.values, expected)
+
+    def test_argsort(self, datetime_series):
+        argsorted = datetime_series.argsort()
+        assert issubclass(argsorted.dtype.type, np.integer)
+
+        # GH#2967 (introduced bug in 0.11-dev I think)
+        s = Series([Timestamp(f"201301{i:02d}") for i in range(1, 6)])
+        assert s.dtype == "datetime64[ns]"
+        shifted = s.shift(-1)
+        assert shifted.dtype == "datetime64[ns]"
+        assert isna(shifted[4])
+
+        result = s.argsort()
+        expected = Series(range(5), dtype=np.intp)
+        tm.assert_series_equal(result, expected)
+
+        msg = "The behavior of Series.argsort in the presence of NA values"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = shifted.argsort()
+        expected = Series(list(range(4)) + [-1], dtype=np.intp)
+        tm.assert_series_equal(result, expected)
+
+    def test_argsort_stable(self):
+        s = Series(np.random.default_rng(2).integers(0, 100, size=10000))
+        mindexer = s.argsort(kind="mergesort")
+        qindexer = s.argsort()
+
+        mexpected = np.argsort(s.values, kind="mergesort")
+        qexpected = np.argsort(s.values, kind="quicksort")
+
+        tm.assert_series_equal(mindexer.astype(np.intp), Series(mexpected))
+        tm.assert_series_equal(qindexer.astype(np.intp), Series(qexpected))
+        msg = (
+            r"ndarray Expected type <class 'numpy\.ndarray'>, "
+            r"found <class 'pandas\.core\.series\.Series'> instead"
+        )
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_numpy_array_equal(qindexer, mindexer)
+
+    def test_argsort_preserve_name(self, datetime_series):
+        result = datetime_series.argsort()
+        assert result.name == datetime_series.name
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_asof.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_asof.py
new file mode 100644
index 0000000000000000000000000000000000000000..31c264d74d06381df4d3f1011caab1f6179391cf
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_asof.py
@@ -0,0 +1,205 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import IncompatibleFrequency
+
+from pandas import (
+    DatetimeIndex,
+    PeriodIndex,
+    Series,
+    Timestamp,
+    date_range,
+    isna,
+    notna,
+    offsets,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesAsof:
+    def test_asof_nanosecond_index_access(self):
+        ts = Timestamp("20130101").as_unit("ns")._value
+        dti = DatetimeIndex([ts + 50 + i for i in range(100)])
+        ser = Series(np.random.default_rng(2).standard_normal(100), index=dti)
+
+        first_value = ser.asof(ser.index[0])
+
+        # GH#46903 previously incorrectly was "day"
+        assert dti.resolution == "nanosecond"
+
+        # this used to not work bc parsing was done by dateutil that didn't
+        #  handle nanoseconds
+        assert first_value == ser["2013-01-01 00:00:00.000000050"]
+
+        expected_ts = np.datetime64("2013-01-01 00:00:00.000000050", "ns")
+        assert first_value == ser[Timestamp(expected_ts)]
+
+    def test_basic(self):
+        # array or list or dates
+        N = 50
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+        ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+        ts.iloc[15:30] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = ts.asof(dates)
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        result = ts.asof(list(dates))
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        mask = (result.index >= lb) & (result.index < ub)
+        rs = result[mask]
+        assert (rs == ts[lb]).all()
+
+        val = result[result.index[result.index >= ub][0]]
+        assert ts[ub] == val
+
+    def test_scalar(self):
+        N = 30
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+        # Explicit cast to float avoid implicit cast when setting nan
+        ts = Series(np.arange(N), index=rng, dtype="float")
+        ts.iloc[5:10] = np.nan
+        ts.iloc[15:20] = np.nan
+
+        val1 = ts.asof(ts.index[7])
+        val2 = ts.asof(ts.index[19])
+
+        assert val1 == ts.iloc[4]
+        assert val2 == ts.iloc[14]
+
+        # accepts strings
+        val1 = ts.asof(str(ts.index[7]))
+        assert val1 == ts.iloc[4]
+
+        # in there
+        result = ts.asof(ts.index[3])
+        assert result == ts.iloc[3]
+
+        # no as of value
+        d = ts.index[0] - offsets.BDay()
+        assert np.isnan(ts.asof(d))
+
+    def test_with_nan(self):
+        # basic asof test
+        rng = date_range("1/1/2000", "1/2/2000", freq="4h")
+        s = Series(np.arange(len(rng)), index=rng)
+        r = s.resample("2h").mean()
+
+        result = r.asof(r.index)
+        expected = Series(
+            [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6.0],
+            index=date_range("1/1/2000", "1/2/2000", freq="2h"),
+        )
+        tm.assert_series_equal(result, expected)
+
+        r.iloc[3:5] = np.nan
+        result = r.asof(r.index)
+        expected = Series(
+            [0, 0, 1, 1, 1, 1, 3, 3, 4, 4, 5, 5, 6.0],
+            index=date_range("1/1/2000", "1/2/2000", freq="2h"),
+        )
+        tm.assert_series_equal(result, expected)
+
+        r.iloc[-3:] = np.nan
+        result = r.asof(r.index)
+        expected = Series(
+            [0, 0, 1, 1, 1, 1, 3, 3, 4, 4, 4, 4, 4.0],
+            index=date_range("1/1/2000", "1/2/2000", freq="2h"),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_periodindex(self):
+        # array or list or dates
+        N = 50
+        rng = period_range("1/1/1990", periods=N, freq="H")
+        ts = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+        ts.iloc[15:30] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="37min")
+
+        result = ts.asof(dates)
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        result = ts.asof(list(dates))
+        assert notna(result).all()
+        lb = ts.index[14]
+        ub = ts.index[30]
+
+        pix = PeriodIndex(result.index.values, freq="H")
+        mask = (pix >= lb) & (pix < ub)
+        rs = result[mask]
+        assert (rs == ts[lb]).all()
+
+        ts.iloc[5:10] = np.nan
+        ts.iloc[15:20] = np.nan
+
+        val1 = ts.asof(ts.index[7])
+        val2 = ts.asof(ts.index[19])
+
+        assert val1 == ts.iloc[4]
+        assert val2 == ts.iloc[14]
+
+        # accepts strings
+        val1 = ts.asof(str(ts.index[7]))
+        assert val1 == ts.iloc[4]
+
+        # in there
+        assert ts.asof(ts.index[3]) == ts.iloc[3]
+
+        # no as of value
+        d = ts.index[0].to_timestamp() - offsets.BDay()
+        assert isna(ts.asof(d))
+
+        # Mismatched freq
+        msg = "Input has different freq"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            ts.asof(rng.asfreq("D"))
+
+    def test_errors(self):
+        s = Series(
+            [1, 2, 3],
+            index=[Timestamp("20130101"), Timestamp("20130103"), Timestamp("20130102")],
+        )
+
+        # non-monotonic
+        assert not s.index.is_monotonic_increasing
+        with pytest.raises(ValueError, match="requires a sorted index"):
+            s.asof(s.index[0])
+
+        # subset with Series
+        N = 10
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+        s = Series(np.random.default_rng(2).standard_normal(N), index=rng)
+        with pytest.raises(ValueError, match="not valid for Series"):
+            s.asof(s.index[0], subset="foo")
+
+    def test_all_nans(self):
+        # GH 15713
+        # series is all nans
+
+        # testing non-default indexes
+        N = 50
+        rng = date_range("1/1/1990", periods=N, freq="53s")
+
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+        result = Series(np.nan, index=rng).asof(dates)
+        expected = Series(np.nan, index=dates)
+        tm.assert_series_equal(result, expected)
+
+        # testing scalar input
+        date = date_range("1/1/1990", periods=N * 3, freq="25s")[0]
+        result = Series(np.nan, index=rng).asof(date)
+        assert isna(result)
+
+        # test name is propagated
+        result = Series(np.nan, index=[1, 2, 3, 4], name="test").asof([4, 5])
+        expected = Series(np.nan, index=[4, 5], name="test")
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_astype.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..03fc6cba2902ae9de115bee7320ed61ece691937
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_astype.py
@@ -0,0 +1,642 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+from importlib import reload
+import string
+import sys
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import iNaT
+import pandas.util._test_decorators as td
+
+from pandas import (
+    NA,
+    Categorical,
+    CategoricalDtype,
+    DatetimeTZDtype,
+    Index,
+    Interval,
+    NaT,
+    Series,
+    Timedelta,
+    Timestamp,
+    cut,
+    date_range,
+)
+import pandas._testing as tm
+
+
+def rand_str(nchars: int) -> str:
+    """
+    Generate one random byte string.
+    """
+    RANDS_CHARS = np.array(
+        list(string.ascii_letters + string.digits), dtype=(np.str_, 1)
+    )
+    return "".join(np.random.default_rng(2).choice(RANDS_CHARS, nchars))
+
+
+class TestAstypeAPI:
+    def test_astype_unitless_dt64_raises(self):
+        # GH#47844
+        ser = Series(["1970-01-01", "1970-01-01", "1970-01-01"], dtype="datetime64[ns]")
+        df = ser.to_frame()
+
+        msg = "Casting to unit-less dtype 'datetime64' is not supported"
+        with pytest.raises(TypeError, match=msg):
+            ser.astype(np.datetime64)
+        with pytest.raises(TypeError, match=msg):
+            df.astype(np.datetime64)
+        with pytest.raises(TypeError, match=msg):
+            ser.astype("datetime64")
+        with pytest.raises(TypeError, match=msg):
+            df.astype("datetime64")
+
+    def test_arg_for_errors_in_astype(self):
+        # see GH#14878
+        ser = Series([1, 2, 3])
+
+        msg = (
+            r"Expected value of kwarg 'errors' to be one of \['raise', "
+            r"'ignore'\]\. Supplied value is 'False'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(np.float64, errors=False)
+
+        ser.astype(np.int8, errors="raise")
+
+    @pytest.mark.parametrize("dtype_class", [dict, Series])
+    def test_astype_dict_like(self, dtype_class):
+        # see GH#7271
+        ser = Series(range(0, 10, 2), name="abc")
+
+        dt1 = dtype_class({"abc": str})
+        result = ser.astype(dt1)
+        expected = Series(["0", "2", "4", "6", "8"], name="abc")
+        tm.assert_series_equal(result, expected)
+
+        dt2 = dtype_class({"abc": "float64"})
+        result = ser.astype(dt2)
+        expected = Series([0.0, 2.0, 4.0, 6.0, 8.0], dtype="float64", name="abc")
+        tm.assert_series_equal(result, expected)
+
+        dt3 = dtype_class({"abc": str, "def": str})
+        msg = (
+            "Only the Series name can be used for the key in Series dtype "
+            r"mappings\."
+        )
+        with pytest.raises(KeyError, match=msg):
+            ser.astype(dt3)
+
+        dt4 = dtype_class({0: str})
+        with pytest.raises(KeyError, match=msg):
+            ser.astype(dt4)
+
+        # GH#16717
+        # if dtypes provided is empty, it should error
+        if dtype_class is Series:
+            dt5 = dtype_class({}, dtype=object)
+        else:
+            dt5 = dtype_class({})
+
+        with pytest.raises(KeyError, match=msg):
+            ser.astype(dt5)
+
+
+class TestAstype:
+    def test_astype_mixed_object_to_dt64tz(self):
+        # pre-2.0 this raised ValueError bc of tz mismatch
+        # xref GH#32581
+        ts = Timestamp("2016-01-04 05:06:07", tz="US/Pacific")
+        ts2 = ts.tz_convert("Asia/Tokyo")
+
+        ser = Series([ts, ts2], dtype=object)
+        res = ser.astype("datetime64[ns, Europe/Brussels]")
+        expected = Series(
+            [ts.tz_convert("Europe/Brussels"), ts2.tz_convert("Europe/Brussels")],
+            dtype="datetime64[ns, Europe/Brussels]",
+        )
+        tm.assert_series_equal(res, expected)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["All"])
+    def test_astype_empty_constructor_equality(self, dtype):
+        # see GH#15524
+
+        if dtype not in (
+            "S",
+            "V",  # poor support (if any) currently
+            "M",
+            "m",  # Generic timestamps raise a ValueError. Already tested.
+        ):
+            init_empty = Series([], dtype=dtype)
+            as_type_empty = Series([]).astype(dtype)
+            tm.assert_series_equal(init_empty, as_type_empty)
+
+    @pytest.mark.parametrize("dtype", [str, np.str_])
+    @pytest.mark.parametrize(
+        "series",
+        [
+            Series([string.digits * 10, rand_str(63), rand_str(64), rand_str(1000)]),
+            Series([string.digits * 10, rand_str(63), rand_str(64), np.nan, 1.0]),
+        ],
+    )
+    def test_astype_str_map(self, dtype, series):
+        # see GH#4405
+        result = series.astype(dtype)
+        expected = series.map(str)
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_float_to_period(self):
+        result = Series([np.nan]).astype("period[D]")
+        expected = Series([NaT], dtype="period[D]")
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_no_pandas_dtype(self):
+        # https://github.com/pandas-dev/pandas/pull/24866
+        ser = Series([1, 2], dtype="int64")
+        # Don't have NumpyEADtype in the public API, so we use `.array.dtype`,
+        # which is a NumpyEADtype.
+        result = ser.astype(ser.array.dtype)
+        tm.assert_series_equal(result, ser)
+
+    @pytest.mark.parametrize("dtype", [np.datetime64, np.timedelta64])
+    def test_astype_generic_timestamp_no_frequency(self, dtype, request):
+        # see GH#15524, GH#15987
+        data = [1]
+        ser = Series(data)
+
+        if np.dtype(dtype).name not in ["timedelta64", "datetime64"]:
+            mark = pytest.mark.xfail(reason="GH#33890 Is assigned ns unit")
+            request.node.add_marker(mark)
+
+        msg = (
+            rf"The '{dtype.__name__}' dtype has no unit\. "
+            rf"Please pass in '{dtype.__name__}\[ns\]' instead."
+        )
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(dtype)
+
+    def test_astype_dt64_to_str(self):
+        # GH#10442 : testing astype(str) is correct for Series/DatetimeIndex
+        dti = date_range("2012-01-01", periods=3)
+        result = Series(dti).astype(str)
+        expected = Series(["2012-01-01", "2012-01-02", "2012-01-03"], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_dt64tz_to_str(self):
+        # GH#10442 : testing astype(str) is correct for Series/DatetimeIndex
+        dti_tz = date_range("2012-01-01", periods=3, tz="US/Eastern")
+        result = Series(dti_tz).astype(str)
+        expected = Series(
+            [
+                "2012-01-01 00:00:00-05:00",
+                "2012-01-02 00:00:00-05:00",
+                "2012-01-03 00:00:00-05:00",
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_datetime(self):
+        ser = Series(iNaT, dtype="M8[ns]", index=range(5))
+
+        ser = ser.astype("O")
+        assert ser.dtype == np.object_
+
+        ser = Series([datetime(2001, 1, 2, 0, 0)])
+
+        ser = ser.astype("O")
+        assert ser.dtype == np.object_
+
+        ser = Series([datetime(2001, 1, 2, 0, 0) for i in range(3)])
+
+        ser[1] = np.nan
+        assert ser.dtype == "M8[ns]"
+
+        ser = ser.astype("O")
+        assert ser.dtype == np.object_
+
+    def test_astype_datetime64tz(self):
+        ser = Series(date_range("20130101", periods=3, tz="US/Eastern"))
+
+        # astype
+        result = ser.astype(object)
+        expected = Series(ser.astype(object), dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        result = Series(ser.values).dt.tz_localize("UTC").dt.tz_convert(ser.dt.tz)
+        tm.assert_series_equal(result, ser)
+
+        # astype - object, preserves on construction
+        result = Series(ser.astype(object))
+        expected = ser.astype(object)
+        tm.assert_series_equal(result, expected)
+
+        # astype - datetime64[ns, tz]
+        msg = "Cannot use .astype to convert from timezone-naive"
+        with pytest.raises(TypeError, match=msg):
+            # dt64->dt64tz astype deprecated
+            Series(ser.values).astype("datetime64[ns, US/Eastern]")
+
+        with pytest.raises(TypeError, match=msg):
+            # dt64->dt64tz astype deprecated
+            Series(ser.values).astype(ser.dtype)
+
+        result = ser.astype("datetime64[ns, CET]")
+        expected = Series(date_range("20130101 06:00:00", periods=3, tz="CET"))
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_str_cast_dt64(self):
+        # see GH#9757
+        ts = Series([Timestamp("2010-01-04 00:00:00")])
+        res = ts.astype(str)
+
+        expected = Series(["2010-01-04"])
+        tm.assert_series_equal(res, expected)
+
+        ts = Series([Timestamp("2010-01-04 00:00:00", tz="US/Eastern")])
+        res = ts.astype(str)
+
+        expected = Series(["2010-01-04 00:00:00-05:00"])
+        tm.assert_series_equal(res, expected)
+
+    def test_astype_str_cast_td64(self):
+        # see GH#9757
+
+        td = Series([Timedelta(1, unit="d")])
+        ser = td.astype(str)
+
+        expected = Series(["1 days"])
+        tm.assert_series_equal(ser, expected)
+
+    def test_dt64_series_astype_object(self):
+        dt64ser = Series(date_range("20130101", periods=3))
+        result = dt64ser.astype(object)
+        assert isinstance(result.iloc[0], datetime)
+        assert result.dtype == np.object_
+
+    def test_td64_series_astype_object(self):
+        tdser = Series(["59 Days", "59 Days", "NaT"], dtype="timedelta64[ns]")
+        result = tdser.astype(object)
+        assert isinstance(result.iloc[0], timedelta)
+        assert result.dtype == np.object_
+
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            (["x", "y", "z"], "string[python]"),
+            pytest.param(
+                ["x", "y", "z"],
+                "string[pyarrow]",
+                marks=td.skip_if_no("pyarrow"),
+            ),
+            (["x", "y", "z"], "category"),
+            (3 * [Timestamp("2020-01-01", tz="UTC")], None),
+            (3 * [Interval(0, 1)], None),
+        ],
+    )
+    @pytest.mark.parametrize("errors", ["raise", "ignore"])
+    def test_astype_ignores_errors_for_extension_dtypes(self, data, dtype, errors):
+        # https://github.com/pandas-dev/pandas/issues/35471
+        ser = Series(data, dtype=dtype)
+        if errors == "ignore":
+            expected = ser
+            result = ser.astype(float, errors="ignore")
+            tm.assert_series_equal(result, expected)
+        else:
+            msg = "(Cannot cast)|(could not convert)"
+            with pytest.raises((ValueError, TypeError), match=msg):
+                ser.astype(float, errors=errors)
+
+    @pytest.mark.parametrize("dtype", [np.float16, np.float32, np.float64])
+    def test_astype_from_float_to_str(self, dtype):
+        # https://github.com/pandas-dev/pandas/issues/36451
+        ser = Series([0.1], dtype=dtype)
+        result = ser.astype(str)
+        expected = Series(["0.1"])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "value, string_value",
+        [
+            (None, "None"),
+            (np.nan, "nan"),
+            (NA, "<NA>"),
+        ],
+    )
+    def test_astype_to_str_preserves_na(self, value, string_value):
+        # https://github.com/pandas-dev/pandas/issues/36904
+        ser = Series(["a", "b", value], dtype=object)
+        result = ser.astype(str)
+        expected = Series(["a", "b", string_value], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["float32", "float64", "int64", "int32"])
+    def test_astype(self, dtype):
+        ser = Series(np.random.default_rng(2).standard_normal(5), name="foo")
+        as_typed = ser.astype(dtype)
+
+        assert as_typed.dtype == dtype
+        assert as_typed.name == ser.name
+
+    @pytest.mark.parametrize("value", [np.nan, np.inf])
+    @pytest.mark.parametrize("dtype", [np.int32, np.int64])
+    def test_astype_cast_nan_inf_int(self, dtype, value):
+        # gh-14265: check NaN and inf raise error when converting to int
+        msg = "Cannot convert non-finite values \\(NA or inf\\) to integer"
+        ser = Series([value])
+
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(dtype)
+
+    @pytest.mark.parametrize("dtype", [int, np.int8, np.int64])
+    def test_astype_cast_object_int_fail(self, dtype):
+        arr = Series(["car", "house", "tree", "1"])
+        msg = r"invalid literal for int\(\) with base 10: 'car'"
+        with pytest.raises(ValueError, match=msg):
+            arr.astype(dtype)
+
+    def test_astype_float_to_uint_negatives_raise(
+        self, float_numpy_dtype, any_unsigned_int_numpy_dtype
+    ):
+        # GH#45151 We don't cast negative numbers to nonsense values
+        # TODO: same for EA float/uint dtypes, signed integers?
+        arr = np.arange(5).astype(float_numpy_dtype) - 3  # includes negatives
+        ser = Series(arr)
+
+        msg = "Cannot losslessly cast from .* to .*"
+        with pytest.raises(ValueError, match=msg):
+            ser.astype(any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            ser.to_frame().astype(any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            # We currently catch and re-raise in Index.astype
+            Index(ser).astype(any_unsigned_int_numpy_dtype)
+
+        with pytest.raises(ValueError, match=msg):
+            ser.array.astype(any_unsigned_int_numpy_dtype)
+
+    def test_astype_cast_object_int(self):
+        arr = Series(["1", "2", "3", "4"], dtype=object)
+        result = arr.astype(int)
+
+        tm.assert_series_equal(result, Series(np.arange(1, 5)))
+
+    def test_astype_unicode(self):
+        # see GH#7758: A bit of magic is required to set
+        # default encoding to utf-8
+        digits = string.digits
+        test_series = [
+            Series([digits * 10, rand_str(63), rand_str(64), rand_str(1000)]),
+            Series(["データーサイエンス、お前はもう死んでいる"]),
+        ]
+
+        former_encoding = None
+
+        if sys.getdefaultencoding() == "utf-8":
+            # GH#45326 as of 2.0 Series.astype matches Index.astype by handling
+            #  bytes with obj.decode() instead of str(obj)
+            item = "野菜食べないとやばい"
+            ser = Series([item.encode()])
+            result = ser.astype(np.str_)
+            expected = Series([item])
+            tm.assert_series_equal(result, expected)
+
+        for ser in test_series:
+            res = ser.astype(np.str_)
+            expec = ser.map(str)
+            tm.assert_series_equal(res, expec)
+
+        # Restore the former encoding
+        if former_encoding is not None and former_encoding != "utf-8":
+            reload(sys)
+            sys.setdefaultencoding(former_encoding)
+
+    def test_astype_bytes(self):
+        # GH#39474
+        result = Series(["foo", "bar", "baz"]).astype(bytes)
+        assert result.dtypes == np.dtype("S3")
+
+    def test_astype_nan_to_bool(self):
+        # GH#43018
+        ser = Series(np.nan, dtype="object")
+        result = ser.astype("bool")
+        expected = Series(True, dtype="bool")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        tm.ALL_INT_EA_DTYPES + tm.FLOAT_EA_DTYPES,
+    )
+    def test_astype_ea_to_datetimetzdtype(self, dtype):
+        # GH37553
+        ser = Series([4, 0, 9], dtype=dtype)
+        result = ser.astype(DatetimeTZDtype(tz="US/Pacific"))
+
+        expected = Series(
+            {
+                0: Timestamp("1969-12-31 16:00:00.000000004-08:00", tz="US/Pacific"),
+                1: Timestamp("1969-12-31 16:00:00.000000000-08:00", tz="US/Pacific"),
+                2: Timestamp("1969-12-31 16:00:00.000000009-08:00", tz="US/Pacific"),
+            }
+        )
+
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_retain_attrs(self, any_numpy_dtype):
+        # GH#44414
+        ser = Series([0, 1, 2, 3])
+        ser.attrs["Location"] = "Michigan"
+
+        result = ser.astype(any_numpy_dtype).attrs
+        expected = ser.attrs
+
+        tm.assert_dict_equal(expected, result)
+
+
+class TestAstypeString:
+    @pytest.mark.parametrize(
+        "data, dtype",
+        [
+            ([True, NA], "boolean"),
+            (["A", NA], "category"),
+            (["2020-10-10", "2020-10-10"], "datetime64[ns]"),
+            (["2020-10-10", "2020-10-10", NaT], "datetime64[ns]"),
+            (
+                ["2012-01-01 00:00:00-05:00", NaT],
+                "datetime64[ns, US/Eastern]",
+            ),
+            ([1, None], "UInt16"),
+            (["1/1/2021", "2/1/2021"], "period[M]"),
+            (["1/1/2021", "2/1/2021", NaT], "period[M]"),
+            (["1 Day", "59 Days", NaT], "timedelta64[ns]"),
+            # currently no way to parse IntervalArray from a list of strings
+        ],
+    )
+    def test_astype_string_to_extension_dtype_roundtrip(
+        self, data, dtype, request, nullable_string_dtype
+    ):
+        if dtype == "boolean":
+            mark = pytest.mark.xfail(
+                reason="TODO StringArray.astype() with missing values #GH40566"
+            )
+            request.node.add_marker(mark)
+        # GH-40351
+        ser = Series(data, dtype=dtype)
+
+        # Note: just passing .astype(dtype) fails for dtype="category"
+        #  with bc ser.dtype.categories will be object dtype whereas
+        #  result.dtype.categories will have string dtype
+        result = ser.astype(nullable_string_dtype).astype(ser.dtype)
+        tm.assert_series_equal(result, ser)
+
+
+class TestAstypeCategorical:
+    def test_astype_categorical_to_other(self):
+        cat = Categorical([f"{i} - {i + 499}" for i in range(0, 10000, 500)])
+        ser = Series(np.random.default_rng(2).integers(0, 10000, 100)).sort_values()
+        ser = cut(ser, range(0, 10500, 500), right=False, labels=cat)
+
+        expected = ser
+        tm.assert_series_equal(ser.astype("category"), expected)
+        tm.assert_series_equal(ser.astype(CategoricalDtype()), expected)
+        msg = r"Cannot cast object dtype to float64"
+        with pytest.raises(ValueError, match=msg):
+            ser.astype("float64")
+
+        cat = Series(Categorical(["a", "b", "b", "a", "a", "c", "c", "c"]))
+        exp = Series(["a", "b", "b", "a", "a", "c", "c", "c"])
+        tm.assert_series_equal(cat.astype("str"), exp)
+        s2 = Series(Categorical(["1", "2", "3", "4"]))
+        exp2 = Series([1, 2, 3, 4]).astype("int")
+        tm.assert_series_equal(s2.astype("int"), exp2)
+
+        # object don't sort correctly, so just compare that we have the same
+        # values
+        def cmp(a, b):
+            tm.assert_almost_equal(np.sort(np.unique(a)), np.sort(np.unique(b)))
+
+        expected = Series(np.array(ser.values), name="value_group")
+        cmp(ser.astype("object"), expected)
+        cmp(ser.astype(np.object_), expected)
+
+        # array conversion
+        tm.assert_almost_equal(np.array(ser), np.array(ser.values))
+
+        tm.assert_series_equal(ser.astype("category"), ser)
+        tm.assert_series_equal(ser.astype(CategoricalDtype()), ser)
+
+        roundtrip_expected = ser.cat.set_categories(
+            ser.cat.categories.sort_values()
+        ).cat.remove_unused_categories()
+        result = ser.astype("object").astype("category")
+        tm.assert_series_equal(result, roundtrip_expected)
+        result = ser.astype("object").astype(CategoricalDtype())
+        tm.assert_series_equal(result, roundtrip_expected)
+
+    def test_astype_categorical_invalid_conversions(self):
+        # invalid conversion (these are NOT a dtype)
+        cat = Categorical([f"{i} - {i + 499}" for i in range(0, 10000, 500)])
+        ser = Series(np.random.default_rng(2).integers(0, 10000, 100)).sort_values()
+        ser = cut(ser, range(0, 10500, 500), right=False, labels=cat)
+
+        msg = (
+            "dtype '<class 'pandas.core.arrays.categorical.Categorical'>' "
+            "not understood"
+        )
+        with pytest.raises(TypeError, match=msg):
+            ser.astype(Categorical)
+        with pytest.raises(TypeError, match=msg):
+            ser.astype("object").astype(Categorical)
+
+    def test_astype_categoricaldtype(self):
+        ser = Series(["a", "b", "a"])
+        result = ser.astype(CategoricalDtype(["a", "b"], ordered=True))
+        expected = Series(Categorical(["a", "b", "a"], ordered=True))
+        tm.assert_series_equal(result, expected)
+
+        result = ser.astype(CategoricalDtype(["a", "b"], ordered=False))
+        expected = Series(Categorical(["a", "b", "a"], ordered=False))
+        tm.assert_series_equal(result, expected)
+
+        result = ser.astype(CategoricalDtype(["a", "b", "c"], ordered=False))
+        expected = Series(
+            Categorical(["a", "b", "a"], categories=["a", "b", "c"], ordered=False)
+        )
+        tm.assert_series_equal(result, expected)
+        tm.assert_index_equal(result.cat.categories, Index(["a", "b", "c"]))
+
+    @pytest.mark.parametrize("name", [None, "foo"])
+    @pytest.mark.parametrize("dtype_ordered", [True, False])
+    @pytest.mark.parametrize("series_ordered", [True, False])
+    def test_astype_categorical_to_categorical(
+        self, name, dtype_ordered, series_ordered
+    ):
+        # GH#10696, GH#18593
+        s_data = list("abcaacbab")
+        s_dtype = CategoricalDtype(list("bac"), ordered=series_ordered)
+        ser = Series(s_data, dtype=s_dtype, name=name)
+
+        # unspecified categories
+        dtype = CategoricalDtype(ordered=dtype_ordered)
+        result = ser.astype(dtype)
+        exp_dtype = CategoricalDtype(s_dtype.categories, dtype_ordered)
+        expected = Series(s_data, name=name, dtype=exp_dtype)
+        tm.assert_series_equal(result, expected)
+
+        # different categories
+        dtype = CategoricalDtype(list("adc"), dtype_ordered)
+        result = ser.astype(dtype)
+        expected = Series(s_data, name=name, dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+        if dtype_ordered is False:
+            # not specifying ordered, so only test once
+            expected = ser
+            result = ser.astype("category")
+            tm.assert_series_equal(result, expected)
+
+    def test_astype_bool_missing_to_categorical(self):
+        # GH-19182
+        ser = Series([True, False, np.nan])
+        assert ser.dtypes == np.object_
+
+        result = ser.astype(CategoricalDtype(categories=[True, False]))
+        expected = Series(Categorical([True, False, np.nan], categories=[True, False]))
+        tm.assert_series_equal(result, expected)
+
+    def test_astype_categories_raises(self):
+        # deprecated GH#17636, removed in GH#27141
+        ser = Series(["a", "b", "a"])
+        with pytest.raises(TypeError, match="got an unexpected"):
+            ser.astype("category", categories=["a", "b"], ordered=True)
+
+    @pytest.mark.parametrize("items", [["a", "b", "c", "a"], [1, 2, 3, 1]])
+    def test_astype_from_categorical(self, items):
+        ser = Series(items)
+        exp = Series(Categorical(items))
+        res = ser.astype("category")
+        tm.assert_series_equal(res, exp)
+
+    def test_astype_from_categorical_with_keywords(self):
+        # with keywords
+        lst = ["a", "b", "c", "a"]
+        ser = Series(lst)
+        exp = Series(Categorical(lst, ordered=True))
+        res = ser.astype(CategoricalDtype(None, ordered=True))
+        tm.assert_series_equal(res, exp)
+
+        exp = Series(Categorical(lst, categories=list("abcdef"), ordered=True))
+        res = ser.astype(CategoricalDtype(list("abcdef"), ordered=True))
+        tm.assert_series_equal(res, exp)
+
+    def test_astype_timedelta64_with_np_nan(self):
+        # GH45798
+        result = Series([Timedelta(1), np.nan], dtype="timedelta64[ns]")
+        expected = Series([Timedelta(1), NaT], dtype="timedelta64[ns]")
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_autocorr.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_autocorr.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1d768cf02f37baceb01b9ef39b91e419cef1e0f
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_autocorr.py
@@ -0,0 +1,30 @@
+import numpy as np
+
+
+class TestAutoCorr:
+    def test_autocorr(self, datetime_series):
+        # Just run the function
+        corr1 = datetime_series.autocorr()
+
+        # Now run it with the lag parameter
+        corr2 = datetime_series.autocorr(lag=1)
+
+        # corr() with lag needs Series of at least length 2
+        if len(datetime_series) <= 2:
+            assert np.isnan(corr1)
+            assert np.isnan(corr2)
+        else:
+            assert corr1 == corr2
+
+        # Choose a random lag between 1 and length of Series - 2
+        # and compare the result with the Series corr() function
+        n = 1 + np.random.default_rng(2).integers(max(1, len(datetime_series) - 2))
+        corr1 = datetime_series.corr(datetime_series.shift(n))
+        corr2 = datetime_series.autocorr(lag=n)
+
+        # corr() with lag needs Series of at least length 2
+        if len(datetime_series) <= 2:
+            assert np.isnan(corr1)
+            assert np.isnan(corr2)
+        else:
+            assert corr1 == corr2
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_between.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_between.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f4931beae589c6c6708fd404052b4eaa4fcded1
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_between.py
@@ -0,0 +1,75 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    bdate_range,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestBetween:
+    def test_between(self):
+        series = Series(date_range("1/1/2000", periods=10))
+        left, right = series[[2, 7]]
+
+        result = series.between(left, right)
+        expected = (series >= left) & (series <= right)
+        tm.assert_series_equal(result, expected)
+
+    def test_between_datetime_object_dtype(self):
+        ser = Series(bdate_range("1/1/2000", periods=20).astype(object))
+        ser[::2] = np.nan
+
+        result = ser[ser.between(ser[3], ser[17])]
+        expected = ser[3:18].dropna()
+        tm.assert_series_equal(result, expected)
+
+        result = ser[ser.between(ser[3], ser[17], inclusive="neither")]
+        expected = ser[5:16].dropna()
+        tm.assert_series_equal(result, expected)
+
+    def test_between_period_values(self):
+        ser = Series(period_range("2000-01-01", periods=10, freq="D"))
+        left, right = ser[[2, 7]]
+        result = ser.between(left, right)
+        expected = (ser >= left) & (ser <= right)
+        tm.assert_series_equal(result, expected)
+
+    def test_between_inclusive_string(self):
+        # GH 40628
+        series = Series(date_range("1/1/2000", periods=10))
+        left, right = series[[2, 7]]
+
+        result = series.between(left, right, inclusive="both")
+        expected = (series >= left) & (series <= right)
+        tm.assert_series_equal(result, expected)
+
+        result = series.between(left, right, inclusive="left")
+        expected = (series >= left) & (series < right)
+        tm.assert_series_equal(result, expected)
+
+        result = series.between(left, right, inclusive="right")
+        expected = (series > left) & (series <= right)
+        tm.assert_series_equal(result, expected)
+
+        result = series.between(left, right, inclusive="neither")
+        expected = (series > left) & (series < right)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inclusive", ["yes", True, False])
+    def test_between_error_args(self, inclusive):
+        # GH 40628
+        series = Series(date_range("1/1/2000", periods=10))
+        left, right = series[[2, 7]]
+
+        value_error_msg = (
+            "Inclusive has to be either string of 'both',"
+            "'left', 'right', or 'neither'."
+        )
+
+        with pytest.raises(ValueError, match=value_error_msg):
+            series = Series(date_range("1/1/2000", periods=10))
+            series.between(left, right, inclusive=inclusive)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_clip.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..da144261ea5b45a43afd55860fcab051684d3570
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_clip.py
@@ -0,0 +1,138 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    Timestamp,
+    isna,
+    notna,
+)
+import pandas._testing as tm
+
+
+class TestSeriesClip:
+    def test_clip(self, datetime_series):
+        val = datetime_series.median()
+
+        assert datetime_series.clip(lower=val).min() == val
+        assert datetime_series.clip(upper=val).max() == val
+
+        result = datetime_series.clip(-0.5, 0.5)
+        expected = np.clip(datetime_series, -0.5, 0.5)
+        tm.assert_series_equal(result, expected)
+        assert isinstance(expected, Series)
+
+    def test_clip_types_and_nulls(self):
+        sers = [
+            Series([np.nan, 1.0, 2.0, 3.0]),
+            Series([None, "a", "b", "c"]),
+            Series(pd.to_datetime([np.nan, 1, 2, 3], unit="D")),
+        ]
+
+        for s in sers:
+            thresh = s[2]
+            lower = s.clip(lower=thresh)
+            upper = s.clip(upper=thresh)
+            assert lower[notna(lower)].min() == thresh
+            assert upper[notna(upper)].max() == thresh
+            assert list(isna(s)) == list(isna(lower))
+            assert list(isna(s)) == list(isna(upper))
+
+    def test_series_clipping_with_na_values(self, any_numeric_ea_dtype, nulls_fixture):
+        # Ensure that clipping method can handle NA values with out failing
+        # GH#40581
+
+        if nulls_fixture is pd.NaT:
+            # constructor will raise, see
+            #  test_constructor_mismatched_null_nullable_dtype
+            pytest.skip("See test_constructor_mismatched_null_nullable_dtype")
+
+        ser = Series([nulls_fixture, 1.0, 3.0], dtype=any_numeric_ea_dtype)
+        s_clipped_upper = ser.clip(upper=2.0)
+        s_clipped_lower = ser.clip(lower=2.0)
+
+        expected_upper = Series([nulls_fixture, 1.0, 2.0], dtype=any_numeric_ea_dtype)
+        expected_lower = Series([nulls_fixture, 2.0, 3.0], dtype=any_numeric_ea_dtype)
+
+        tm.assert_series_equal(s_clipped_upper, expected_upper)
+        tm.assert_series_equal(s_clipped_lower, expected_lower)
+
+    def test_clip_with_na_args(self):
+        """Should process np.nan argument as None"""
+        # GH#17276
+        s = Series([1, 2, 3])
+
+        tm.assert_series_equal(s.clip(np.nan), Series([1, 2, 3]))
+        tm.assert_series_equal(s.clip(upper=np.nan, lower=np.nan), Series([1, 2, 3]))
+
+        # GH#19992
+        tm.assert_series_equal(s.clip(lower=[0, 4, np.nan]), Series([1, 4, 3]))
+        tm.assert_series_equal(s.clip(upper=[1, np.nan, 1]), Series([1, 2, 1]))
+
+        # GH#40420
+        s = Series([1, 2, 3])
+        result = s.clip(0, [np.nan, np.nan, np.nan])
+        tm.assert_series_equal(s, result)
+
+    def test_clip_against_series(self):
+        # GH#6966
+
+        s = Series([1.0, 1.0, 4.0])
+
+        lower = Series([1.0, 2.0, 3.0])
+        upper = Series([1.5, 2.5, 3.5])
+
+        tm.assert_series_equal(s.clip(lower, upper), Series([1.0, 2.0, 3.5]))
+        tm.assert_series_equal(s.clip(1.5, upper), Series([1.5, 1.5, 3.5]))
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize("upper", [[1, 2, 3], np.asarray([1, 2, 3])])
+    def test_clip_against_list_like(self, inplace, upper):
+        # GH#15390
+        original = Series([5, 6, 7])
+        result = original.clip(upper=upper, inplace=inplace)
+        expected = Series([1, 2, 3])
+
+        if inplace:
+            result = original
+        tm.assert_series_equal(result, expected, check_exact=True)
+
+    def test_clip_with_datetimes(self):
+        # GH#11838
+        # naive and tz-aware datetimes
+
+        t = Timestamp("2015-12-01 09:30:30")
+        s = Series([Timestamp("2015-12-01 09:30:00"), Timestamp("2015-12-01 09:31:00")])
+        result = s.clip(upper=t)
+        expected = Series(
+            [Timestamp("2015-12-01 09:30:00"), Timestamp("2015-12-01 09:30:30")]
+        )
+        tm.assert_series_equal(result, expected)
+
+        t = Timestamp("2015-12-01 09:30:30", tz="US/Eastern")
+        s = Series(
+            [
+                Timestamp("2015-12-01 09:30:00", tz="US/Eastern"),
+                Timestamp("2015-12-01 09:31:00", tz="US/Eastern"),
+            ]
+        )
+        result = s.clip(upper=t)
+        expected = Series(
+            [
+                Timestamp("2015-12-01 09:30:00", tz="US/Eastern"),
+                Timestamp("2015-12-01 09:30:30", tz="US/Eastern"),
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_clip_with_timestamps_and_oob_datetimes(self):
+        # GH-42794
+        ser = Series([datetime(1, 1, 1), datetime(9999, 9, 9)])
+
+        result = ser.clip(lower=Timestamp.min, upper=Timestamp.max)
+        expected = Series([Timestamp.min, Timestamp.max], dtype="object")
+
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_combine.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_combine.py
new file mode 100644
index 0000000000000000000000000000000000000000..75d47e3daa10339f4c4cc7b35c52f24bbb20277a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_combine.py
@@ -0,0 +1,17 @@
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestCombine:
+    def test_combine_scalar(self):
+        # GH#21248
+        # Note - combine() with another Series is tested elsewhere because
+        # it is used when testing operators
+        ser = Series([i * 10 for i in range(5)])
+        result = ser.combine(3, lambda x, y: x + y)
+        expected = Series([i * 10 + 3 for i in range(5)])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.combine(22, lambda x, y: min(x, y))
+        expected = Series([min(i * 10, 22) for i in range(5)])
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_combine_first.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_combine_first.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2d8eab1cb38bd0acda702405aff77dc97d4a6ab
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_combine_first.py
@@ -0,0 +1,149 @@
+from datetime import datetime
+
+import numpy as np
+
+import pandas as pd
+from pandas import (
+    Period,
+    Series,
+    date_range,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+class TestCombineFirst:
+    def test_combine_first_period_datetime(self):
+        # GH#3367
+        didx = date_range(start="1950-01-31", end="1950-07-31", freq="M")
+        pidx = period_range(start=Period("1950-1"), end=Period("1950-7"), freq="M")
+        # check to be consistent with DatetimeIndex
+        for idx in [didx, pidx]:
+            a = Series([1, np.nan, np.nan, 4, 5, np.nan, 7], index=idx)
+            b = Series([9, 9, 9, 9, 9, 9, 9], index=idx)
+
+            result = a.combine_first(b)
+            expected = Series([1, 9, 9, 4, 5, 9, 7], index=idx, dtype=np.float64)
+            tm.assert_series_equal(result, expected)
+
+    def test_combine_first_name(self, datetime_series):
+        result = datetime_series.combine_first(datetime_series[:5])
+        assert result.name == datetime_series.name
+
+    def test_combine_first(self):
+        values = tm.makeIntIndex(20).values.astype(float)
+        series = Series(values, index=tm.makeIntIndex(20))
+
+        series_copy = series * 2
+        series_copy[::2] = np.nan
+
+        # nothing used from the input
+        combined = series.combine_first(series_copy)
+
+        tm.assert_series_equal(combined, series)
+
+        # Holes filled from input
+        combined = series_copy.combine_first(series)
+        assert np.isfinite(combined).all()
+
+        tm.assert_series_equal(combined[::2], series[::2])
+        tm.assert_series_equal(combined[1::2], series_copy[1::2])
+
+        # mixed types
+        index = tm.makeStringIndex(20)
+        floats = Series(np.random.default_rng(2).standard_normal(20), index=index)
+        strings = Series(tm.makeStringIndex(10), index=index[::2])
+
+        combined = strings.combine_first(floats)
+
+        tm.assert_series_equal(strings, combined.loc[index[::2]])
+        tm.assert_series_equal(floats[1::2].astype(object), combined.loc[index[1::2]])
+
+        # corner case
+        ser = Series([1.0, 2, 3], index=[0, 1, 2])
+        empty = Series([], index=[], dtype=object)
+        msg = "The behavior of array concatenation with empty entries is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.combine_first(empty)
+        ser.index = ser.index.astype("O")
+        tm.assert_series_equal(ser, result)
+
+    def test_combine_first_dt64(self):
+        s0 = to_datetime(Series(["2010", np.nan]))
+        s1 = to_datetime(Series([np.nan, "2011"]))
+        rs = s0.combine_first(s1)
+        xp = to_datetime(Series(["2010", "2011"]))
+        tm.assert_series_equal(rs, xp)
+
+        s0 = to_datetime(Series(["2010", np.nan]))
+        s1 = Series([np.nan, "2011"])
+        rs = s0.combine_first(s1)
+
+        xp = Series([datetime(2010, 1, 1), "2011"], dtype="datetime64[ns]")
+
+        tm.assert_series_equal(rs, xp)
+
+    def test_combine_first_dt_tz_values(self, tz_naive_fixture):
+        ser1 = Series(
+            pd.DatetimeIndex(["20150101", "20150102", "20150103"], tz=tz_naive_fixture),
+            name="ser1",
+        )
+        ser2 = Series(
+            pd.DatetimeIndex(["20160514", "20160515", "20160516"], tz=tz_naive_fixture),
+            index=[2, 3, 4],
+            name="ser2",
+        )
+        result = ser1.combine_first(ser2)
+        exp_vals = pd.DatetimeIndex(
+            ["20150101", "20150102", "20150103", "20160515", "20160516"],
+            tz=tz_naive_fixture,
+        )
+        exp = Series(exp_vals, name="ser1")
+        tm.assert_series_equal(exp, result)
+
+    def test_combine_first_timezone_series_with_empty_series(self):
+        # GH 41800
+        time_index = date_range(
+            datetime(2021, 1, 1, 1),
+            datetime(2021, 1, 1, 10),
+            freq="H",
+            tz="Europe/Rome",
+        )
+        s1 = Series(range(10), index=time_index)
+        s2 = Series(index=time_index)
+        msg = "The behavior of array concatenation with empty entries is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s1.combine_first(s2)
+        tm.assert_series_equal(result, s1)
+
+    def test_combine_first_preserves_dtype(self):
+        # GH51764
+        s1 = Series([1666880195890293744, 1666880195890293837])
+        s2 = Series([1, 2, 3])
+        result = s1.combine_first(s2)
+        expected = Series([1666880195890293744, 1666880195890293837, 3])
+        tm.assert_series_equal(result, expected)
+
+    def test_combine_mixed_timezone(self):
+        # GH 26283
+        uniform_tz = Series({pd.Timestamp("2019-05-01", tz="UTC"): 1.0})
+        multi_tz = Series(
+            {
+                pd.Timestamp("2019-05-01 01:00:00+0100", tz="Europe/London"): 2.0,
+                pd.Timestamp("2019-05-02", tz="UTC"): 3.0,
+            }
+        )
+
+        result = uniform_tz.combine_first(multi_tz)
+        expected = Series(
+            [1.0, 3.0],
+            index=pd.Index(
+                [
+                    pd.Timestamp("2019-05-01 00:00:00+00:00", tz="UTC"),
+                    pd.Timestamp("2019-05-02 00:00:00+00:00", tz="UTC"),
+                ],
+                dtype="object",
+            ),
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_compare.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe2016a245ec7c1373c72f40c7b6e7d899cf4f96
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_compare.py
@@ -0,0 +1,141 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("align_axis", [0, 1, "index", "columns"])
+def test_compare_axis(align_axis):
+    # GH#30429
+    s1 = pd.Series(["a", "b", "c"])
+    s2 = pd.Series(["x", "b", "z"])
+
+    result = s1.compare(s2, align_axis=align_axis)
+
+    if align_axis in (1, "columns"):
+        indices = pd.Index([0, 2])
+        columns = pd.Index(["self", "other"])
+        expected = pd.DataFrame(
+            [["a", "x"], ["c", "z"]], index=indices, columns=columns
+        )
+        tm.assert_frame_equal(result, expected)
+    else:
+        indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+        expected = pd.Series(["a", "x", "c", "z"], index=indices)
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep_shape, keep_equal",
+    [
+        (True, False),
+        (False, True),
+        (True, True),
+        # False, False case is already covered in test_compare_axis
+    ],
+)
+def test_compare_various_formats(keep_shape, keep_equal):
+    s1 = pd.Series(["a", "b", "c"])
+    s2 = pd.Series(["x", "b", "z"])
+
+    result = s1.compare(s2, keep_shape=keep_shape, keep_equal=keep_equal)
+
+    if keep_shape:
+        indices = pd.Index([0, 1, 2])
+        columns = pd.Index(["self", "other"])
+        if keep_equal:
+            expected = pd.DataFrame(
+                [["a", "x"], ["b", "b"], ["c", "z"]], index=indices, columns=columns
+            )
+        else:
+            expected = pd.DataFrame(
+                [["a", "x"], [np.nan, np.nan], ["c", "z"]],
+                index=indices,
+                columns=columns,
+            )
+    else:
+        indices = pd.Index([0, 2])
+        columns = pd.Index(["self", "other"])
+        expected = pd.DataFrame(
+            [["a", "x"], ["c", "z"]], index=indices, columns=columns
+        )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_equal_nulls():
+    # We want to make sure two NaNs are considered the same
+    # and dropped where applicable
+    s1 = pd.Series(["a", "b", np.nan])
+    s2 = pd.Series(["x", "b", np.nan])
+
+    result = s1.compare(s2)
+    expected = pd.DataFrame([["a", "x"]], columns=["self", "other"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_non_equal_nulls():
+    # We want to make sure the relevant NaNs do not get dropped
+    s1 = pd.Series(["a", "b", "c"])
+    s2 = pd.Series(["x", "b", np.nan])
+
+    result = s1.compare(s2, align_axis=0)
+
+    indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+    expected = pd.Series(["a", "x", "c", np.nan], index=indices)
+    tm.assert_series_equal(result, expected)
+
+
+def test_compare_multi_index():
+    index = pd.MultiIndex.from_arrays([[0, 0, 1], [0, 1, 2]])
+    s1 = pd.Series(["a", "b", "c"], index=index)
+    s2 = pd.Series(["x", "b", "z"], index=index)
+
+    result = s1.compare(s2, align_axis=0)
+
+    indices = pd.MultiIndex.from_arrays(
+        [[0, 0, 1, 1], [0, 0, 2, 2], ["self", "other", "self", "other"]]
+    )
+    expected = pd.Series(["a", "x", "c", "z"], index=indices)
+    tm.assert_series_equal(result, expected)
+
+
+def test_compare_unaligned_objects():
+    # test Series with different indices
+    msg = "Can only compare identically-labeled Series objects"
+    with pytest.raises(ValueError, match=msg):
+        ser1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
+        ser2 = pd.Series([1, 2, 3], index=["a", "b", "d"])
+        ser1.compare(ser2)
+
+    # test Series with different lengths
+    msg = "Can only compare identically-labeled Series objects"
+    with pytest.raises(ValueError, match=msg):
+        ser1 = pd.Series([1, 2, 3])
+        ser2 = pd.Series([1, 2, 3, 4])
+        ser1.compare(ser2)
+
+
+def test_compare_datetime64_and_string():
+    # Issue https://github.com/pandas-dev/pandas/issues/45506
+    # Catch OverflowError when comparing datetime64 and string
+    data = [
+        {"a": "2015-07-01", "b": "08335394550"},
+        {"a": "2015-07-02", "b": "+49 (0) 0345 300033"},
+        {"a": "2015-07-03", "b": "+49(0)2598 04457"},
+        {"a": "2015-07-04", "b": "0741470003"},
+        {"a": "2015-07-05", "b": "04181 83668"},
+    ]
+    dtypes = {"a": "datetime64[ns]", "b": "string"}
+    df = pd.DataFrame(data=data).astype(dtypes)
+
+    result_eq1 = df["a"].eq(df["b"])
+    result_eq2 = df["a"] == df["b"]
+    result_neq = df["a"] != df["b"]
+
+    expected_eq = pd.Series([False] * 5)  # For .eq and ==
+    expected_neq = pd.Series([True] * 5)  # For !=
+
+    tm.assert_series_equal(result_eq1, expected_eq)
+    tm.assert_series_equal(result_eq2, expected_eq)
+    tm.assert_series_equal(result_neq, expected_neq)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_convert_dtypes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_convert_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1c79d0f00365ed5e2bd2fae08ce57483f51182c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_convert_dtypes.py
@@ -0,0 +1,267 @@
+from itertools import product
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+# Each test case consists of a tuple with the data and dtype to create the
+# test Series, the default dtype for the expected result (which is valid
+# for most cases), and the specific cases where the result deviates from
+# this default. Those overrides are defined as a dict with (keyword, val) as
+# dictionary key. In case of multiple items, the last override takes precedence.
+
+
+@pytest.fixture(
+    params=[
+        (
+            # data
+            [1, 2, 3],
+            # original dtype
+            np.dtype("int32"),
+            # default expected dtype
+            "Int32",
+            # exceptions on expected dtype
+            {("convert_integer", False): np.dtype("int32")},
+        ),
+        (
+            [1, 2, 3],
+            np.dtype("int64"),
+            "Int64",
+            {("convert_integer", False): np.dtype("int64")},
+        ),
+        (
+            ["x", "y", "z"],
+            np.dtype("O"),
+            pd.StringDtype(),
+            {("convert_string", False): np.dtype("O")},
+        ),
+        (
+            [True, False, np.nan],
+            np.dtype("O"),
+            pd.BooleanDtype(),
+            {("convert_boolean", False): np.dtype("O")},
+        ),
+        (
+            ["h", "i", np.nan],
+            np.dtype("O"),
+            pd.StringDtype(),
+            {("convert_string", False): np.dtype("O")},
+        ),
+        (  # GH32117
+            ["h", "i", 1],
+            np.dtype("O"),
+            np.dtype("O"),
+            {},
+        ),
+        (
+            [10, np.nan, 20],
+            np.dtype("float"),
+            "Int64",
+            {
+                ("convert_integer", False, "convert_floating", True): "Float64",
+                ("convert_integer", False, "convert_floating", False): np.dtype(
+                    "float"
+                ),
+            },
+        ),
+        (
+            [np.nan, 100.5, 200],
+            np.dtype("float"),
+            "Float64",
+            {("convert_floating", False): np.dtype("float")},
+        ),
+        (
+            [3, 4, 5],
+            "Int8",
+            "Int8",
+            {},
+        ),
+        (
+            [[1, 2], [3, 4], [5]],
+            None,
+            np.dtype("O"),
+            {},
+        ),
+        (
+            [4, 5, 6],
+            np.dtype("uint32"),
+            "UInt32",
+            {("convert_integer", False): np.dtype("uint32")},
+        ),
+        (
+            [-10, 12, 13],
+            np.dtype("i1"),
+            "Int8",
+            {("convert_integer", False): np.dtype("i1")},
+        ),
+        (
+            [1.2, 1.3],
+            np.dtype("float32"),
+            "Float32",
+            {("convert_floating", False): np.dtype("float32")},
+        ),
+        (
+            [1, 2.0],
+            object,
+            "Int64",
+            {
+                ("convert_integer", False): "Float64",
+                ("convert_integer", False, "convert_floating", False): np.dtype(
+                    "float"
+                ),
+                ("infer_objects", False): np.dtype("object"),
+            },
+        ),
+        (
+            [1, 2.5],
+            object,
+            "Float64",
+            {
+                ("convert_floating", False): np.dtype("float"),
+                ("infer_objects", False): np.dtype("object"),
+            },
+        ),
+        (["a", "b"], pd.CategoricalDtype(), pd.CategoricalDtype(), {}),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
+            pd.DatetimeTZDtype(tz="UTC"),
+            pd.DatetimeTZDtype(tz="UTC"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
+            "datetime64[ns]",
+            np.dtype("datetime64[ns]"),
+            {},
+        ),
+        (
+            pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
+            object,
+            np.dtype("datetime64[ns]"),
+            {("infer_objects", False): np.dtype("object")},
+        ),
+        (
+            pd.period_range("1/1/2011", freq="M", periods=3),
+            None,
+            pd.PeriodDtype("M"),
+            {},
+        ),
+        (
+            pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
+            None,
+            pd.IntervalDtype("int64", "right"),
+            {},
+        ),
+    ]
+)
+def test_cases(request):
+    return request.param
+
+
+class TestSeriesConvertDtypes:
+    @pytest.mark.parametrize("params", product(*[(True, False)] * 5))
+    def test_convert_dtypes(
+        self,
+        test_cases,
+        params,
+    ):
+        data, maindtype, expected_default, expected_other = test_cases
+        if (
+            hasattr(data, "dtype")
+            and data.dtype == "M8[ns]"
+            and isinstance(maindtype, pd.DatetimeTZDtype)
+        ):
+            # this astype is deprecated in favor of tz_localize
+            msg = "Cannot use .astype to convert from timezone-naive dtype"
+            with pytest.raises(TypeError, match=msg):
+                pd.Series(data, dtype=maindtype)
+            return
+
+        if maindtype is not None:
+            series = pd.Series(data, dtype=maindtype)
+        else:
+            series = pd.Series(data)
+
+        result = series.convert_dtypes(*params)
+
+        param_names = [
+            "infer_objects",
+            "convert_string",
+            "convert_integer",
+            "convert_boolean",
+            "convert_floating",
+        ]
+        params_dict = dict(zip(param_names, params))
+
+        expected_dtype = expected_default
+        for spec, dtype in expected_other.items():
+            if all(params_dict[key] is val for key, val in zip(spec[::2], spec[1::2])):
+                expected_dtype = dtype
+
+        expected = pd.Series(data, dtype=expected_dtype)
+        tm.assert_series_equal(result, expected)
+
+        # Test that it is a copy
+        copy = series.copy(deep=True)
+
+        if result.notna().sum() > 0 and result.dtype in ["interval[int64, right]"]:
+            with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+                result[result.notna()] = np.nan
+        else:
+            result[result.notna()] = np.nan
+
+        # Make sure original not changed
+        tm.assert_series_equal(series, copy)
+
+    def test_convert_string_dtype(self, nullable_string_dtype):
+        # https://github.com/pandas-dev/pandas/issues/31731 -> converting columns
+        # that are already string dtype
+        df = pd.DataFrame(
+            {"A": ["a", "b", pd.NA], "B": ["ä", "ö", "ü"]}, dtype=nullable_string_dtype
+        )
+        result = df.convert_dtypes()
+        tm.assert_frame_equal(df, result)
+
+    def test_convert_bool_dtype(self):
+        # GH32287
+        df = pd.DataFrame({"A": pd.array([True])})
+        tm.assert_frame_equal(df, df.convert_dtypes())
+
+    def test_convert_byte_string_dtype(self):
+        # GH-43183
+        byte_str = b"binary-string"
+
+        df = pd.DataFrame(data={"A": byte_str}, index=[0])
+        result = df.convert_dtypes()
+        expected = df
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "infer_objects, dtype", [(True, "Int64"), (False, "object")]
+    )
+    def test_convert_dtype_object_with_na(self, infer_objects, dtype):
+        # GH#48791
+        ser = pd.Series([1, pd.NA])
+        result = ser.convert_dtypes(infer_objects=infer_objects)
+        expected = pd.Series([1, pd.NA], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "infer_objects, dtype", [(True, "Float64"), (False, "object")]
+    )
+    def test_convert_dtype_object_with_na_float(self, infer_objects, dtype):
+        # GH#48791
+        ser = pd.Series([1.5, pd.NA])
+        result = ser.convert_dtypes(infer_objects=infer_objects)
+        expected = pd.Series([1.5, pd.NA], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_convert_dtypes_pyarrow_to_np_nullable(self):
+        # GH 53648
+        pytest.importorskip("pyarrow")
+        ser = pd.Series(range(2), dtype="int32[pyarrow]")
+        result = ser.convert_dtypes(dtype_backend="numpy_nullable")
+        expected = pd.Series(range(2), dtype="Int32")
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_copy.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..77600e0e7d2931c3ece3149821e02c8cf8cd3125
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_copy.py
@@ -0,0 +1,89 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestCopy:
+    @pytest.mark.parametrize("deep", ["default", None, False, True])
+    def test_copy(self, deep, using_copy_on_write):
+        ser = Series(np.arange(10), dtype="float64")
+
+        # default deep is True
+        if deep == "default":
+            ser2 = ser.copy()
+        else:
+            ser2 = ser.copy(deep=deep)
+
+        if using_copy_on_write:
+            # INFO(CoW) a shallow copy doesn't yet copy the data
+            # but parent will not be modified (CoW)
+            if deep is None or deep is False:
+                assert np.may_share_memory(ser.values, ser2.values)
+            else:
+                assert not np.may_share_memory(ser.values, ser2.values)
+
+        ser2[::2] = np.nan
+
+        if deep is not False or using_copy_on_write:
+            # Did not modify original Series
+            assert np.isnan(ser2[0])
+            assert not np.isnan(ser[0])
+        else:
+            # we DID modify the original Series
+            assert np.isnan(ser2[0])
+            assert np.isnan(ser[0])
+
+    @pytest.mark.parametrize("deep", ["default", None, False, True])
+    def test_copy_tzaware(self, deep, using_copy_on_write):
+        # GH#11794
+        # copy of tz-aware
+        expected = Series([Timestamp("2012/01/01", tz="UTC")])
+        expected2 = Series([Timestamp("1999/01/01", tz="UTC")])
+
+        ser = Series([Timestamp("2012/01/01", tz="UTC")])
+
+        if deep == "default":
+            ser2 = ser.copy()
+        else:
+            ser2 = ser.copy(deep=deep)
+
+        if using_copy_on_write:
+            # INFO(CoW) a shallow copy doesn't yet copy the data
+            # but parent will not be modified (CoW)
+            if deep is None or deep is False:
+                assert np.may_share_memory(ser.values, ser2.values)
+            else:
+                assert not np.may_share_memory(ser.values, ser2.values)
+
+        ser2[0] = Timestamp("1999/01/01", tz="UTC")
+
+        # default deep is True
+        if deep is not False or using_copy_on_write:
+            # Did not modify original Series
+            tm.assert_series_equal(ser2, expected2)
+            tm.assert_series_equal(ser, expected)
+        else:
+            # we DID modify the original Series
+            tm.assert_series_equal(ser2, expected2)
+            tm.assert_series_equal(ser, expected2)
+
+    def test_copy_name(self, datetime_series):
+        result = datetime_series.copy()
+        assert result.name == datetime_series.name
+
+    def test_copy_index_name_checking(self, datetime_series):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
+
+        datetime_series.index.name = None
+        assert datetime_series.index.name is None
+        assert datetime_series is datetime_series
+
+        cp = datetime_series.copy()
+        cp.index.name = "foo"
+        assert datetime_series.index.name is None
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_count.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_count.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ba163f347198a5533c67fdeffeb4012a804066f
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_count.py
@@ -0,0 +1,34 @@
+import numpy as np
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestSeriesCount:
+    def test_count(self, datetime_series):
+        assert datetime_series.count() == len(datetime_series)
+
+        datetime_series[::2] = np.nan
+
+        assert datetime_series.count() == np.isfinite(datetime_series).sum()
+
+    def test_count_inf_as_na(self):
+        # GH#29478
+        ser = Series([pd.Timestamp("1990/1/1")])
+        msg = "use_inf_as_na option is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            with pd.option_context("use_inf_as_na", True):
+                assert ser.count() == 1
+
+    def test_count_categorical(self):
+        ser = Series(
+            Categorical(
+                [np.nan, 1, 2, np.nan], categories=[5, 4, 3, 2, 1], ordered=True
+            )
+        )
+        result = ser.count()
+        assert result == 2
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_cov_corr.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_cov_corr.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2d5d1ee090ac5ba58a24741ca349a422af52315
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_cov_corr.py
@@ -0,0 +1,176 @@
+import math
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    isna,
+)
+import pandas._testing as tm
+
+
+class TestSeriesCov:
+    def test_cov(self, datetime_series):
+        # full overlap
+        tm.assert_almost_equal(
+            datetime_series.cov(datetime_series), datetime_series.std() ** 2
+        )
+
+        # partial overlap
+        tm.assert_almost_equal(
+            datetime_series[:15].cov(datetime_series[5:]),
+            datetime_series[5:15].std() ** 2,
+        )
+
+        # No overlap
+        assert np.isnan(datetime_series[::2].cov(datetime_series[1::2]))
+
+        # all NA
+        cp = datetime_series[:10].copy()
+        cp[:] = np.nan
+        assert isna(cp.cov(cp))
+
+        # min_periods
+        assert isna(datetime_series[:15].cov(datetime_series[5:], min_periods=12))
+
+        ts1 = datetime_series[:15].reindex(datetime_series.index)
+        ts2 = datetime_series[5:].reindex(datetime_series.index)
+        assert isna(ts1.cov(ts2, min_periods=12))
+
+    @pytest.mark.parametrize("test_ddof", [None, 0, 1, 2, 3])
+    @pytest.mark.parametrize("dtype", ["float64", "Float64"])
+    def test_cov_ddof(self, test_ddof, dtype):
+        # GH#34611
+        np_array1 = np.random.default_rng(2).random(10)
+        np_array2 = np.random.default_rng(2).random(10)
+
+        s1 = Series(np_array1, dtype=dtype)
+        s2 = Series(np_array2, dtype=dtype)
+
+        result = s1.cov(s2, ddof=test_ddof)
+        expected = np.cov(np_array1, np_array2, ddof=test_ddof)[0][1]
+        assert math.isclose(expected, result)
+
+
+class TestSeriesCorr:
+    @pytest.mark.parametrize("dtype", ["float64", "Float64"])
+    def test_corr(self, datetime_series, dtype):
+        stats = pytest.importorskip("scipy.stats")
+
+        datetime_series = datetime_series.astype(dtype)
+
+        # full overlap
+        tm.assert_almost_equal(datetime_series.corr(datetime_series), 1)
+
+        # partial overlap
+        tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), 1)
+
+        assert isna(datetime_series[:15].corr(datetime_series[5:], min_periods=12))
+
+        ts1 = datetime_series[:15].reindex(datetime_series.index)
+        ts2 = datetime_series[5:].reindex(datetime_series.index)
+        assert isna(ts1.corr(ts2, min_periods=12))
+
+        # No overlap
+        assert np.isnan(datetime_series[::2].corr(datetime_series[1::2]))
+
+        # all NA
+        cp = datetime_series[:10].copy()
+        cp[:] = np.nan
+        assert isna(cp.corr(cp))
+
+        A = tm.makeTimeSeries()
+        B = tm.makeTimeSeries()
+        result = A.corr(B)
+        expected, _ = stats.pearsonr(A, B)
+        tm.assert_almost_equal(result, expected)
+
+    def test_corr_rank(self):
+        stats = pytest.importorskip("scipy.stats")
+
+        # kendall and spearman
+        A = tm.makeTimeSeries()
+        B = tm.makeTimeSeries()
+        A[-5:] = A[:5]
+        result = A.corr(B, method="kendall")
+        expected = stats.kendalltau(A, B)[0]
+        tm.assert_almost_equal(result, expected)
+
+        result = A.corr(B, method="spearman")
+        expected = stats.spearmanr(A, B)[0]
+        tm.assert_almost_equal(result, expected)
+
+        # results from R
+        A = Series(
+            [
+                -0.89926396,
+                0.94209606,
+                -1.03289164,
+                -0.95445587,
+                0.76910310,
+                -0.06430576,
+                -2.09704447,
+                0.40660407,
+                -0.89926396,
+                0.94209606,
+            ]
+        )
+        B = Series(
+            [
+                -1.01270225,
+                -0.62210117,
+                -1.56895827,
+                0.59592943,
+                -0.01680292,
+                1.17258718,
+                -1.06009347,
+                -0.10222060,
+                -0.89076239,
+                0.89372375,
+            ]
+        )
+        kexp = 0.4319297
+        sexp = 0.5853767
+        tm.assert_almost_equal(A.corr(B, method="kendall"), kexp)
+        tm.assert_almost_equal(A.corr(B, method="spearman"), sexp)
+
+    def test_corr_invalid_method(self):
+        # GH PR #22298
+        s1 = Series(np.random.default_rng(2).standard_normal(10))
+        s2 = Series(np.random.default_rng(2).standard_normal(10))
+        msg = "method must be either 'pearson', 'spearman', 'kendall', or a callable, "
+        with pytest.raises(ValueError, match=msg):
+            s1.corr(s2, method="____")
+
+    def test_corr_callable_method(self, datetime_series):
+        # simple correlation example
+        # returns 1 if exact equality, 0 otherwise
+        my_corr = lambda a, b: 1.0 if (a == b).all() else 0.0
+
+        # simple example
+        s1 = Series([1, 2, 3, 4, 5])
+        s2 = Series([5, 4, 3, 2, 1])
+        expected = 0
+        tm.assert_almost_equal(s1.corr(s2, method=my_corr), expected)
+
+        # full overlap
+        tm.assert_almost_equal(
+            datetime_series.corr(datetime_series, method=my_corr), 1.0
+        )
+
+        # partial overlap
+        tm.assert_almost_equal(
+            datetime_series[:15].corr(datetime_series[5:], method=my_corr), 1.0
+        )
+
+        # No overlap
+        assert np.isnan(
+            datetime_series[::2].corr(datetime_series[1::2], method=my_corr)
+        )
+
+        # dataframe example
+        df = pd.DataFrame([s1, s2])
+        expected = pd.DataFrame([{0: 1.0, 1: 0}, {0: 0, 1: 1.0}])
+        tm.assert_almost_equal(df.transpose().corr(method=my_corr), expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_describe.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_describe.py
new file mode 100644
index 0000000000000000000000000000000000000000..79ec11feb530817e735cf1d45cd7985839cd4d05
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_describe.py
@@ -0,0 +1,203 @@
+import numpy as np
+import pytest
+
+from pandas.compat.numpy import np_version_gte1p25
+
+from pandas.core.dtypes.common import (
+    is_complex_dtype,
+    is_extension_array_dtype,
+)
+
+from pandas import (
+    NA,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesDescribe:
+    def test_describe_ints(self):
+        ser = Series([0, 1, 2, 3, 4], name="int_data")
+        result = ser.describe()
+        expected = Series(
+            [5, 2, ser.std(), 0, 1, 2, 3, 4],
+            name="int_data",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_bools(self):
+        ser = Series([True, True, False, False, False], name="bool_data")
+        result = ser.describe()
+        expected = Series(
+            [5, 2, False, 3], name="bool_data", index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_strs(self):
+        ser = Series(["a", "a", "b", "c", "d"], name="str_data")
+        result = ser.describe()
+        expected = Series(
+            [5, 4, "a", 2], name="str_data", index=["count", "unique", "top", "freq"]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_timedelta64(self):
+        ser = Series(
+            [
+                Timedelta("1 days"),
+                Timedelta("2 days"),
+                Timedelta("3 days"),
+                Timedelta("4 days"),
+                Timedelta("5 days"),
+            ],
+            name="timedelta_data",
+        )
+        result = ser.describe()
+        expected = Series(
+            [5, ser[2], ser.std(), ser[0], ser[1], ser[2], ser[3], ser[4]],
+            name="timedelta_data",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_period(self):
+        ser = Series(
+            [Period("2020-01", "M"), Period("2020-01", "M"), Period("2019-12", "M")],
+            name="period_data",
+        )
+        result = ser.describe()
+        expected = Series(
+            [3, 2, ser[0], 2],
+            name="period_data",
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_empty_object(self):
+        # https://github.com/pandas-dev/pandas/issues/27183
+        s = Series([None, None], dtype=object)
+        result = s.describe()
+        expected = Series(
+            [0, 0, np.nan, np.nan],
+            dtype=object,
+            index=["count", "unique", "top", "freq"],
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = s[:0].describe()
+        tm.assert_series_equal(result, expected)
+        # ensure NaN, not None
+        assert np.isnan(result.iloc[2])
+        assert np.isnan(result.iloc[3])
+
+    def test_describe_with_tz(self, tz_naive_fixture):
+        # GH 21332
+        tz = tz_naive_fixture
+        name = str(tz_naive_fixture)
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s = Series(date_range(start, end, tz=tz), name=name)
+        result = s.describe()
+        expected = Series(
+            [
+                5,
+                Timestamp(2018, 1, 3).tz_localize(tz),
+                start.tz_localize(tz),
+                s[1],
+                s[2],
+                s[3],
+                end.tz_localize(tz),
+            ],
+            name=name,
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_with_tz_numeric(self):
+        name = tz = "CET"
+        start = Timestamp(2018, 1, 1)
+        end = Timestamp(2018, 1, 5)
+        s = Series(date_range(start, end, tz=tz), name=name)
+
+        result = s.describe()
+
+        expected = Series(
+            [
+                5,
+                Timestamp("2018-01-03 00:00:00", tz=tz),
+                Timestamp("2018-01-01 00:00:00", tz=tz),
+                Timestamp("2018-01-02 00:00:00", tz=tz),
+                Timestamp("2018-01-03 00:00:00", tz=tz),
+                Timestamp("2018-01-04 00:00:00", tz=tz),
+                Timestamp("2018-01-05 00:00:00", tz=tz),
+            ],
+            name=name,
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime_is_numeric_includes_datetime(self):
+        s = Series(date_range("2012", periods=3))
+        result = s.describe()
+        expected = Series(
+            [
+                3,
+                Timestamp("2012-01-02"),
+                Timestamp("2012-01-01"),
+                Timestamp("2012-01-01T12:00:00"),
+                Timestamp("2012-01-02"),
+                Timestamp("2012-01-02T12:00:00"),
+                Timestamp("2012-01-03"),
+            ],
+            index=["count", "mean", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.filterwarnings("ignore:Casting complex values to real discards")
+    def test_numeric_result_dtype(self, any_numeric_dtype):
+        # GH#48340 - describe should always return float on non-complex numeric input
+        if is_extension_array_dtype(any_numeric_dtype):
+            dtype = "Float64"
+        else:
+            dtype = "complex128" if is_complex_dtype(any_numeric_dtype) else None
+
+        ser = Series([0, 1], dtype=any_numeric_dtype)
+        if dtype == "complex128" and np_version_gte1p25:
+            with pytest.raises(
+                TypeError, match=r"^a must be an array of real numbers$"
+            ):
+                ser.describe()
+            return
+        result = ser.describe()
+        expected = Series(
+            [
+                2.0,
+                0.5,
+                ser.std(),
+                0,
+                0.25,
+                0.5,
+                0.75,
+                1.0,
+            ],
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+            dtype=dtype,
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_describe_one_element_ea(self):
+        # GH#52515
+        ser = Series([0.0], dtype="Float64")
+        with tm.assert_produces_warning(None):
+            result = ser.describe()
+        expected = Series(
+            [1, 0, NA, 0, 0, 0, 0, 0],
+            dtype="Float64",
+            index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
+        )
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_diff.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..938a0f9ac49d180027b89ee8423f85b241cad8ee
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_diff.py
@@ -0,0 +1,84 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    TimedeltaIndex,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesDiff:
+    def test_diff_np(self):
+        # TODO(__array_function__): could make np.diff return a Series
+        #  matching ser.diff()
+
+        ser = Series(np.arange(5))
+
+        res = np.diff(ser)
+        expected = np.array([1, 1, 1, 1])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_diff_int(self):
+        # int dtype
+        a = 10000000000000000
+        b = a + 1
+        ser = Series([a, b])
+
+        result = ser.diff()
+        assert result[1] == 1
+
+    def test_diff_tz(self):
+        # Combined datetime diff, normal diff and boolean diff test
+        ts = tm.makeTimeSeries(name="ts")
+        ts.diff()
+
+        # neg n
+        result = ts.diff(-1)
+        expected = ts - ts.shift(-1)
+        tm.assert_series_equal(result, expected)
+
+        # 0
+        result = ts.diff(0)
+        expected = ts - ts
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_dt64(self):
+        # datetime diff (GH#3100)
+        ser = Series(date_range("20130102", periods=5))
+        result = ser.diff()
+        expected = ser - ser.shift(1)
+        tm.assert_series_equal(result, expected)
+
+        # timedelta diff
+        result = result - result.shift(1)  # previous result
+        expected = expected.diff()  # previously expected
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_dt64tz(self):
+        # with tz
+        ser = Series(
+            date_range("2000-01-01 09:00:00", periods=5, tz="US/Eastern"), name="foo"
+        )
+        result = ser.diff()
+        expected = Series(TimedeltaIndex(["NaT"] + ["1 days"] * 4), name="foo")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input,output,diff",
+        [([False, True, True, False, False], [np.nan, True, False, True, False], 1)],
+    )
+    def test_diff_bool(self, input, output, diff):
+        # boolean series (test for fixing #17294)
+        ser = Series(input)
+        result = ser.diff()
+        expected = Series(output)
+        tm.assert_series_equal(result, expected)
+
+    def test_diff_object_dtype(self):
+        # object series
+        ser = Series([False, True, 5.0, np.nan, True, False])
+        result = ser.diff()
+        expected = ser - ser.shift(1)
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_drop.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_drop.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d9a469915cfb718aba9020b82105c66d93b429f
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_drop.py
@@ -0,0 +1,99 @@
+import pytest
+
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.api.types import is_bool_dtype
+
+
+@pytest.mark.parametrize(
+    "data, index, drop_labels, axis, expected_data, expected_index",
+    [
+        # Unique Index
+        ([1, 2], ["one", "two"], ["two"], 0, [1], ["one"]),
+        ([1, 2], ["one", "two"], ["two"], "rows", [1], ["one"]),
+        ([1, 1, 2], ["one", "two", "one"], ["two"], 0, [1, 2], ["one", "one"]),
+        # GH 5248 Non-Unique Index
+        ([1, 1, 2], ["one", "two", "one"], "two", 0, [1, 2], ["one", "one"]),
+        ([1, 1, 2], ["one", "two", "one"], ["one"], 0, [1], ["two"]),
+        ([1, 1, 2], ["one", "two", "one"], "one", 0, [1], ["two"]),
+    ],
+)
+def test_drop_unique_and_non_unique_index(
+    data, index, axis, drop_labels, expected_data, expected_index
+):
+    ser = Series(data=data, index=index)
+    result = ser.drop(drop_labels, axis=axis)
+    expected = Series(data=expected_data, index=expected_index)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, index, drop_labels, axis, error_type, error_desc",
+    [
+        # single string/tuple-like
+        (range(3), list("abc"), "bc", 0, KeyError, "not found in axis"),
+        # bad axis
+        (range(3), list("abc"), ("a",), 0, KeyError, "not found in axis"),
+        (range(3), list("abc"), "one", "columns", ValueError, "No axis named columns"),
+    ],
+)
+def test_drop_exception_raised(data, index, drop_labels, axis, error_type, error_desc):
+    ser = Series(data, index=index)
+    with pytest.raises(error_type, match=error_desc):
+        ser.drop(drop_labels, axis=axis)
+
+
+def test_drop_with_ignore_errors():
+    # errors='ignore'
+    ser = Series(range(3), index=list("abc"))
+    result = ser.drop("bc", errors="ignore")
+    tm.assert_series_equal(result, ser)
+    result = ser.drop(["a", "d"], errors="ignore")
+    expected = ser.iloc[1:]
+    tm.assert_series_equal(result, expected)
+
+    # GH 8522
+    ser = Series([2, 3], index=[True, False])
+    assert is_bool_dtype(ser.index)
+    assert ser.index.dtype == bool
+    result = ser.drop(True)
+    expected = Series([3], index=[False])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("index", [[1, 2, 3], [1, 1, 3]])
+@pytest.mark.parametrize("drop_labels", [[], [1], [3]])
+def test_drop_empty_list(index, drop_labels):
+    # GH 21494
+    expected_index = [i for i in index if i not in drop_labels]
+    series = Series(index=index, dtype=object).drop(drop_labels)
+    expected = Series(index=expected_index, dtype=object)
+    tm.assert_series_equal(series, expected)
+
+
+@pytest.mark.parametrize(
+    "data, index, drop_labels",
+    [
+        (None, [1, 2, 3], [1, 4]),
+        (None, [1, 2, 2], [1, 4]),
+        ([2, 3], [0, 1], [False, True]),
+    ],
+)
+def test_drop_non_empty_list(data, index, drop_labels):
+    # GH 21494 and GH 16877
+    dtype = object if data is None else None
+    ser = Series(data=data, index=index, dtype=dtype)
+    with pytest.raises(KeyError, match="not found in axis"):
+        ser.drop(drop_labels)
+
+
+def test_drop_index_ea_dtype(any_numeric_ea_dtype):
+    # GH#45860
+    df = Series(100, index=Index([1, 2, 2], dtype=any_numeric_ea_dtype))
+    idx = Index([df.index[1]])
+    result = df.drop(idx)
+    expected = Series(100, index=Index([1], dtype=any_numeric_ea_dtype))
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_drop_duplicates.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_drop_duplicates.py
new file mode 100644
index 0000000000000000000000000000000000000000..10b2e98586365929e4ff05df0d93660d55cf8850
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_drop_duplicates.py
@@ -0,0 +1,267 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, False, False, True, True, False])),
+        ("last", Series([False, True, True, False, False, False, False])),
+        (False, Series([False, True, True, False, True, True, False])),
+    ],
+)
+def test_drop_duplicates(any_numpy_dtype, keep, expected):
+    tc = Series([1, 0, 3, 5, 3, 0, 4], dtype=np.dtype(any_numpy_dtype))
+
+    if tc.dtype == "bool":
+        pytest.skip("tested separately in test_drop_duplicates_bool")
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
+    sc = tc.copy()
+    return_value = sc.drop_duplicates(keep=keep, inplace=True)
+    assert return_value is None
+    tm.assert_series_equal(sc, tc[~expected])
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, True])),
+        ("last", Series([True, True, False, False])),
+        (False, Series([True, True, True, True])),
+    ],
+)
+def test_drop_duplicates_bool(keep, expected):
+    tc = Series([True, False, True, False])
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+    tm.assert_series_equal(tc.drop_duplicates(keep=keep), tc[~expected])
+    sc = tc.copy()
+    return_value = sc.drop_duplicates(keep=keep, inplace=True)
+    tm.assert_series_equal(sc, tc[~expected])
+    assert return_value is None
+
+
+@pytest.mark.parametrize("values", [[], list(range(5))])
+def test_drop_duplicates_no_duplicates(any_numpy_dtype, keep, values):
+    tc = Series(values, dtype=np.dtype(any_numpy_dtype))
+    expected = Series([False] * len(tc), dtype="bool")
+
+    if tc.dtype == "bool":
+        # 0 -> False and 1-> True
+        # any other value would be duplicated
+        tc = tc[:2]
+        expected = expected[:2]
+
+    tm.assert_series_equal(tc.duplicated(keep=keep), expected)
+
+    result_dropped = tc.drop_duplicates(keep=keep)
+    tm.assert_series_equal(result_dropped, tc)
+
+    # validate shallow copy
+    assert result_dropped is not tc
+
+
+class TestSeriesDropDuplicates:
+    @pytest.fixture(
+        params=["int_", "uint", "float64", "str_", "timedelta64[h]", "datetime64[D]"]
+    )
+    def dtype(self, request):
+        return request.param
+
+    @pytest.fixture
+    def cat_series_unused_category(self, dtype, ordered):
+        # Test case 1
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
+        input1 = np.array([1, 2, 3, 3], dtype=np.dtype(dtype))
+        cat = Categorical(input1, categories=cat_array, ordered=ordered)
+        tc1 = Series(cat)
+        return tc1
+
+    def test_drop_duplicates_categorical_non_bool(self, cat_series_unused_category):
+        tc1 = cat_series_unused_category
+
+        expected = Series([False, False, False, True])
+
+        result = tc1.duplicated()
+        tm.assert_series_equal(result, expected)
+
+        result = tc1.drop_duplicates()
+        tm.assert_series_equal(result, tc1[~expected])
+
+        sc = tc1.copy()
+        return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc1[~expected])
+
+    def test_drop_duplicates_categorical_non_bool_keeplast(
+        self, cat_series_unused_category
+    ):
+        tc1 = cat_series_unused_category
+
+        expected = Series([False, False, True, False])
+
+        result = tc1.duplicated(keep="last")
+        tm.assert_series_equal(result, expected)
+
+        result = tc1.drop_duplicates(keep="last")
+        tm.assert_series_equal(result, tc1[~expected])
+
+        sc = tc1.copy()
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc1[~expected])
+
+    def test_drop_duplicates_categorical_non_bool_keepfalse(
+        self, cat_series_unused_category
+    ):
+        tc1 = cat_series_unused_category
+
+        expected = Series([False, False, True, True])
+
+        result = tc1.duplicated(keep=False)
+        tm.assert_series_equal(result, expected)
+
+        result = tc1.drop_duplicates(keep=False)
+        tm.assert_series_equal(result, tc1[~expected])
+
+        sc = tc1.copy()
+        return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc1[~expected])
+
+    @pytest.fixture
+    def cat_series(self, dtype, ordered):
+        # no unused categories, unlike cat_series_unused_category
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
+        input2 = np.array([1, 2, 3, 5, 3, 2, 4], dtype=np.dtype(dtype))
+        cat = Categorical(input2, categories=cat_array, ordered=ordered)
+        tc2 = Series(cat)
+        return tc2
+
+    def test_drop_duplicates_categorical_non_bool2(self, cat_series):
+        tc2 = cat_series
+
+        expected = Series([False, False, False, False, True, True, False])
+
+        result = tc2.duplicated()
+        tm.assert_series_equal(result, expected)
+
+        result = tc2.drop_duplicates()
+        tm.assert_series_equal(result, tc2[~expected])
+
+        sc = tc2.copy()
+        return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_non_bool2_keeplast(self, cat_series):
+        tc2 = cat_series
+
+        expected = Series([False, True, True, False, False, False, False])
+
+        result = tc2.duplicated(keep="last")
+        tm.assert_series_equal(result, expected)
+
+        result = tc2.drop_duplicates(keep="last")
+        tm.assert_series_equal(result, tc2[~expected])
+
+        sc = tc2.copy()
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_non_bool2_keepfalse(self, cat_series):
+        tc2 = cat_series
+
+        expected = Series([False, True, True, False, True, True, False])
+
+        result = tc2.duplicated(keep=False)
+        tm.assert_series_equal(result, expected)
+
+        result = tc2.drop_duplicates(keep=False)
+        tm.assert_series_equal(result, tc2[~expected])
+
+        sc = tc2.copy()
+        return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_bool(self, ordered):
+        tc = Series(
+            Categorical(
+                [True, False, True, False], categories=[True, False], ordered=ordered
+            )
+        )
+
+        expected = Series([False, False, True, True])
+        tm.assert_series_equal(tc.duplicated(), expected)
+        tm.assert_series_equal(tc.drop_duplicates(), tc[~expected])
+        sc = tc.copy()
+        return_value = sc.drop_duplicates(inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc[~expected])
+
+        expected = Series([True, True, False, False])
+        tm.assert_series_equal(tc.duplicated(keep="last"), expected)
+        tm.assert_series_equal(tc.drop_duplicates(keep="last"), tc[~expected])
+        sc = tc.copy()
+        return_value = sc.drop_duplicates(keep="last", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc[~expected])
+
+        expected = Series([True, True, True, True])
+        tm.assert_series_equal(tc.duplicated(keep=False), expected)
+        tm.assert_series_equal(tc.drop_duplicates(keep=False), tc[~expected])
+        sc = tc.copy()
+        return_value = sc.drop_duplicates(keep=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(sc, tc[~expected])
+
+    def test_drop_duplicates_categorical_bool_na(self, nulls_fixture):
+        # GH#44351
+        ser = Series(
+            Categorical(
+                [True, False, True, False, nulls_fixture],
+                categories=[True, False],
+                ordered=True,
+            )
+        )
+        result = ser.drop_duplicates()
+        expected = Series(
+            Categorical([True, False, np.nan], categories=[True, False], ordered=True),
+            index=[0, 1, 4],
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_drop_duplicates_ignore_index(self):
+        # GH#48304
+        ser = Series([1, 2, 2, 3])
+        result = ser.drop_duplicates(ignore_index=True)
+        expected = Series([1, 2, 3])
+        tm.assert_series_equal(result, expected)
+
+    def test_duplicated_arrow_dtype(self):
+        pytest.importorskip("pyarrow")
+        ser = Series([True, False, None, False], dtype="bool[pyarrow]")
+        result = ser.drop_duplicates()
+        expected = Series([True, False, None], dtype="bool[pyarrow]")
+        tm.assert_series_equal(result, expected)
+
+    def test_drop_duplicates_arrow_strings(self):
+        # GH#54904
+        pa = pytest.importorskip("pyarrow")
+        ser = Series(["a", "a"], dtype=pd.ArrowDtype(pa.string()))
+        result = ser.drop_duplicates()
+        expecetd = Series(["a"], dtype=pd.ArrowDtype(pa.string()))
+        tm.assert_series_equal(result, expecetd)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_dropna.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_dropna.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a7c27929d405841967b60612371bf1dc5dc67a9
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_dropna.py
@@ -0,0 +1,113 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    IntervalIndex,
+    NaT,
+    Period,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestDropna:
+    def test_dropna_empty(self):
+        ser = Series([], dtype=object)
+
+        assert len(ser.dropna()) == 0
+        return_value = ser.dropna(inplace=True)
+        assert return_value is None
+        assert len(ser) == 0
+
+        # invalid axis
+        msg = "No axis named 1 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser.dropna(axis=1)
+
+    def test_dropna_preserve_name(self, datetime_series):
+        datetime_series[:5] = np.nan
+        result = datetime_series.dropna()
+        assert result.name == datetime_series.name
+        name = datetime_series.name
+        ts = datetime_series.copy()
+        return_value = ts.dropna(inplace=True)
+        assert return_value is None
+        assert ts.name == name
+
+    def test_dropna_no_nan(self):
+        for ser in [
+            Series([1, 2, 3], name="x"),
+            Series([False, True, False], name="x"),
+        ]:
+            result = ser.dropna()
+            tm.assert_series_equal(result, ser)
+            assert result is not ser
+
+            s2 = ser.copy()
+            return_value = s2.dropna(inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(s2, ser)
+
+    def test_dropna_intervals(self):
+        ser = Series(
+            [np.nan, 1, 2, 3],
+            IntervalIndex.from_arrays([np.nan, 0, 1, 2], [np.nan, 1, 2, 3]),
+        )
+
+        result = ser.dropna()
+        expected = ser.iloc[1:]
+        tm.assert_series_equal(result, expected)
+
+    def test_dropna_period_dtype(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+        result = ser.dropna()
+        expected = Series([Period("2011-01", freq="M")])
+
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime64_tz_dropna(self):
+        # DatetimeLikeBlock
+        ser = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                NaT,
+                Timestamp("2011-01-03 10:00"),
+                NaT,
+            ]
+        )
+        result = ser.dropna()
+        expected = Series(
+            [Timestamp("2011-01-01 10:00"), Timestamp("2011-01-03 10:00")], index=[0, 2]
+        )
+        tm.assert_series_equal(result, expected)
+
+        # DatetimeTZBlock
+        idx = DatetimeIndex(
+            ["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz="Asia/Tokyo"
+        )
+        ser = Series(idx)
+        assert ser.dtype == "datetime64[ns, Asia/Tokyo]"
+        result = ser.dropna()
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz="Asia/Tokyo"),
+                Timestamp("2011-01-03 10:00", tz="Asia/Tokyo"),
+            ],
+            index=[0, 2],
+        )
+        assert result.dtype == "datetime64[ns, Asia/Tokyo]"
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [1, 1.5])
+    def test_dropna_ignore_index(self, val):
+        # GH#31725
+        ser = Series([1, 2, val], index=[3, 2, 1])
+        result = ser.dropna(ignore_index=True)
+        expected = Series([1, 2, val])
+        tm.assert_series_equal(result, expected)
+
+        ser.dropna(ignore_index=True, inplace=True)
+        tm.assert_series_equal(ser, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_dtypes.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_dtypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..82260bc2a65b9f7e387532b380b9ce013d29cbb7
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_dtypes.py
@@ -0,0 +1,7 @@
+import numpy as np
+
+
+class TestSeriesDtypes:
+    def test_dtype(self, datetime_series):
+        assert datetime_series.dtype == np.dtype("float64")
+        assert datetime_series.dtypes == np.dtype("float64")
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_duplicated.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_duplicated.py
new file mode 100644
index 0000000000000000000000000000000000000000..e177b5275d855fffbede91280d9ee7fb61ece2cd
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_duplicated.py
@@ -0,0 +1,77 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    Categorical,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True], name="name")),
+        ("last", Series([True, True, False, False, False], name="name")),
+        (False, Series([True, True, True, False, True], name="name")),
+    ],
+)
+def test_duplicated_keep(keep, expected):
+    ser = Series(["a", "b", "b", "c", "a"], name="name")
+
+    result = ser.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep, expected",
+    [
+        ("first", Series([False, False, True, False, True])),
+        ("last", Series([True, True, False, False, False])),
+        (False, Series([True, True, True, False, True])),
+    ],
+)
+def test_duplicated_nan_none(keep, expected):
+    ser = Series([np.nan, 3, 3, None, np.nan], dtype=object)
+
+    result = ser.duplicated(keep=keep)
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicated_categorical_bool_na(nulls_fixture):
+    # GH#44351
+    ser = Series(
+        Categorical(
+            [True, False, True, False, nulls_fixture],
+            categories=[True, False],
+            ordered=True,
+        )
+    )
+    result = ser.duplicated()
+    expected = Series([False, False, True, True, False])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "keep, vals",
+    [
+        ("last", [True, True, False]),
+        ("first", [False, True, True]),
+        (False, [True, True, True]),
+    ],
+)
+def test_duplicated_mask(keep, vals):
+    # GH#48150
+    ser = Series([1, 2, NA, NA, NA], dtype="Int64")
+    result = ser.duplicated(keep=keep)
+    expected = Series([False, False] + vals)
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicated_mask_no_duplicated_na(keep):
+    # GH#48150
+    ser = Series([1, 2, NA], dtype="Int64")
+    result = ser.duplicated(keep=keep)
+    expected = Series([False, False, False])
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_equals.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_equals.py
new file mode 100644
index 0000000000000000000000000000000000000000..b94723b7cbddf1d93250677cb58f96f824db1659
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_equals.py
@@ -0,0 +1,143 @@
+from contextlib import nullcontext
+import copy
+
+import numpy as np
+import pytest
+
+from pandas._libs.missing import is_matching_na
+from pandas.compat.numpy import np_version_gte1p25
+
+from pandas.core.dtypes.common import is_float
+
+from pandas import (
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "arr, idx",
+    [
+        ([1, 2, 3, 4], [0, 2, 1, 3]),
+        ([1, np.nan, 3, np.nan], [0, 2, 1, 3]),
+        (
+            [1, np.nan, 3, np.nan],
+            MultiIndex.from_tuples([(0, "a"), (1, "b"), (2, "c"), (3, "c")]),
+        ),
+    ],
+)
+def test_equals(arr, idx):
+    s1 = Series(arr, index=idx)
+    s2 = s1.copy()
+    assert s1.equals(s2)
+
+    s1[1] = 9
+    assert not s1.equals(s2)
+
+
+@pytest.mark.parametrize(
+    "val", [1, 1.1, 1 + 1j, True, "abc", [1, 2], (1, 2), {1, 2}, {"a": 1}, None]
+)
+def test_equals_list_array(val):
+    # GH20676 Verify equals operator for list of Numpy arrays
+    arr = np.array([1, 2])
+    s1 = Series([arr, arr])
+    s2 = s1.copy()
+    assert s1.equals(s2)
+
+    s1[1] = val
+
+    cm = (
+        tm.assert_produces_warning(FutureWarning, check_stacklevel=False)
+        if isinstance(val, str) and not np_version_gte1p25
+        else nullcontext()
+    )
+    with cm:
+        assert not s1.equals(s2)
+
+
+def test_equals_false_negative():
+    # GH8437 Verify false negative behavior of equals function for dtype object
+    arr = [False, np.nan]
+    s1 = Series(arr)
+    s2 = s1.copy()
+    s3 = Series(index=range(2), dtype=object)
+    s4 = s3.copy()
+    s5 = s3.copy()
+    s6 = s3.copy()
+
+    s3[:-1] = s4[:-1] = s5[0] = s6[0] = False
+    assert s1.equals(s1)
+    assert s1.equals(s2)
+    assert s1.equals(s3)
+    assert s1.equals(s4)
+    assert s1.equals(s5)
+    assert s5.equals(s6)
+
+
+def test_equals_matching_nas():
+    # matching but not identical NAs
+    left = Series([np.datetime64("NaT")], dtype=object)
+    right = Series([np.datetime64("NaT")], dtype=object)
+    assert left.equals(right)
+    assert Index(left).equals(Index(right))
+    assert left.array.equals(right.array)
+
+    left = Series([np.timedelta64("NaT")], dtype=object)
+    right = Series([np.timedelta64("NaT")], dtype=object)
+    assert left.equals(right)
+    assert Index(left).equals(Index(right))
+    assert left.array.equals(right.array)
+
+    left = Series([np.float64("NaN")], dtype=object)
+    right = Series([np.float64("NaN")], dtype=object)
+    assert left.equals(right)
+    assert Index(left, dtype=left.dtype).equals(Index(right, dtype=right.dtype))
+    assert left.array.equals(right.array)
+
+
+def test_equals_mismatched_nas(nulls_fixture, nulls_fixture2):
+    # GH#39650
+    left = nulls_fixture
+    right = nulls_fixture2
+    if hasattr(right, "copy"):
+        right = right.copy()
+    else:
+        right = copy.copy(right)
+
+    ser = Series([left], dtype=object)
+    ser2 = Series([right], dtype=object)
+
+    if is_matching_na(left, right):
+        assert ser.equals(ser2)
+    elif (left is None and is_float(right)) or (right is None and is_float(left)):
+        assert ser.equals(ser2)
+    else:
+        assert not ser.equals(ser2)
+
+
+def test_equals_none_vs_nan():
+    # GH#39650
+    ser = Series([1, None], dtype=object)
+    ser2 = Series([1, np.nan], dtype=object)
+
+    assert ser.equals(ser2)
+    assert Index(ser, dtype=ser.dtype).equals(Index(ser2, dtype=ser2.dtype))
+    assert ser.array.equals(ser2.array)
+
+
+def test_equals_None_vs_float():
+    # GH#44190
+    left = Series([-np.inf, np.nan, -1.0, 0.0, 1.0, 10 / 3, np.inf], dtype=object)
+    right = Series([None] * len(left))
+
+    # these series were found to be equal due to a bug, check that they are correctly
+    # found to not equal
+    assert not left.equals(right)
+    assert not right.equals(left)
+    assert not left.to_frame().equals(right.to_frame())
+    assert not right.to_frame().equals(left.to_frame())
+    assert not Index(left, dtype="object").equals(Index(right, dtype="object"))
+    assert not Index(right, dtype="object").equals(Index(left, dtype="object"))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_explode.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_explode.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8a9eb6f89fdef5fb16fe5f2a1d0490c02477ab8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_explode.py
@@ -0,0 +1,165 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_basic():
+    s = pd.Series([[0, 1, 2], np.nan, [], (3, 4)], index=list("abcd"), name="foo")
+    result = s.explode()
+    expected = pd.Series(
+        [0, 1, 2, np.nan, np.nan, 3, 4], index=list("aaabcdd"), dtype=object, name="foo"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_mixed_type():
+    s = pd.Series(
+        [[0, 1, 2], np.nan, None, np.array([]), pd.Series(["a", "b"])], name="foo"
+    )
+    result = s.explode()
+    expected = pd.Series(
+        [0, 1, 2, np.nan, None, np.nan, "a", "b"],
+        index=[0, 0, 0, 1, 2, 3, 4, 4],
+        dtype=object,
+        name="foo",
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_empty():
+    s = pd.Series(dtype=object)
+    result = s.explode()
+    expected = s.copy()
+    tm.assert_series_equal(result, expected)
+
+
+def test_nested_lists():
+    s = pd.Series([[[1, 2, 3]], [1, 2], 1])
+    result = s.explode()
+    expected = pd.Series([[1, 2, 3], 1, 2, 1], index=[0, 1, 1, 2])
+    tm.assert_series_equal(result, expected)
+
+
+def test_multi_index():
+    s = pd.Series(
+        [[0, 1, 2], np.nan, [], (3, 4)],
+        name="foo",
+        index=pd.MultiIndex.from_product([list("ab"), range(2)], names=["foo", "bar"]),
+    )
+    result = s.explode()
+    index = pd.MultiIndex.from_tuples(
+        [("a", 0), ("a", 0), ("a", 0), ("a", 1), ("b", 0), ("b", 1), ("b", 1)],
+        names=["foo", "bar"],
+    )
+    expected = pd.Series(
+        [0, 1, 2, np.nan, np.nan, 3, 4], index=index, dtype=object, name="foo"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_large():
+    s = pd.Series([range(256)]).explode()
+    result = s.explode()
+    tm.assert_series_equal(result, s)
+
+
+def test_invert_array():
+    df = pd.DataFrame({"a": pd.date_range("20190101", periods=3, tz="UTC")})
+
+    listify = df.apply(lambda x: x.array, axis=1)
+    result = listify.explode()
+    tm.assert_series_equal(result, df["a"].rename())
+
+
+@pytest.mark.parametrize(
+    "s", [pd.Series([1, 2, 3]), pd.Series(pd.date_range("2019", periods=3, tz="UTC"))]
+)
+def test_non_object_dtype(s):
+    result = s.explode()
+    tm.assert_series_equal(result, s)
+
+
+def test_typical_usecase():
+    df = pd.DataFrame(
+        [{"var1": "a,b,c", "var2": 1}, {"var1": "d,e,f", "var2": 2}],
+        columns=["var1", "var2"],
+    )
+    exploded = df.var1.str.split(",").explode()
+    result = df[["var2"]].join(exploded)
+    expected = pd.DataFrame(
+        {"var2": [1, 1, 1, 2, 2, 2], "var1": list("abcdef")},
+        columns=["var2", "var1"],
+        index=[0, 0, 0, 1, 1, 1],
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_nested_EA():
+    # a nested EA array
+    s = pd.Series(
+        [
+            pd.date_range("20170101", periods=3, tz="UTC"),
+            pd.date_range("20170104", periods=3, tz="UTC"),
+        ]
+    )
+    result = s.explode()
+    expected = pd.Series(
+        pd.date_range("20170101", periods=6, tz="UTC"), index=[0, 0, 0, 1, 1, 1]
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_duplicate_index():
+    # GH 28005
+    s = pd.Series([[1, 2], [3, 4]], index=[0, 0])
+    result = s.explode()
+    expected = pd.Series([1, 2, 3, 4], index=[0, 0, 0, 0], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_ignore_index():
+    # GH 34932
+    s = pd.Series([[1, 2], [3, 4]])
+    result = s.explode(ignore_index=True)
+    expected = pd.Series([1, 2, 3, 4], index=[0, 1, 2, 3], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_explode_sets():
+    # https://github.com/pandas-dev/pandas/issues/35614
+    s = pd.Series([{"a", "b", "c"}], index=[1])
+    result = s.explode().sort_values()
+    expected = pd.Series(["a", "b", "c"], index=[1, 1, 1])
+    tm.assert_series_equal(result, expected)
+
+
+def test_explode_scalars_can_ignore_index():
+    # https://github.com/pandas-dev/pandas/issues/40487
+    s = pd.Series([1, 2, 3], index=["a", "b", "c"])
+    result = s.explode(ignore_index=True)
+    expected = pd.Series([1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("ignore_index", [True, False])
+def test_explode_pyarrow_list_type(ignore_index):
+    # GH 53602
+    pa = pytest.importorskip("pyarrow")
+
+    data = [
+        [None, None],
+        [1],
+        [],
+        [2, 3],
+        None,
+    ]
+    ser = pd.Series(data, dtype=pd.ArrowDtype(pa.list_(pa.int64())))
+    result = ser.explode(ignore_index=ignore_index)
+    expected = pd.Series(
+        data=[None, None, 1, None, 2, 3, None],
+        index=None if ignore_index else [0, 0, 1, 2, 3, 3, 4],
+        dtype=pd.ArrowDtype(pa.int64()),
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_fillna.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_fillna.py
new file mode 100644
index 0000000000000000000000000000000000000000..46bc14da59eb01a78b2887f8ef43b5b9ee0822fe
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_fillna.py
@@ -0,0 +1,999 @@
+from datetime import (
+    datetime,
+    timedelta,
+    timezone,
+)
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    NaT,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+from pandas.core.arrays import period_array
+
+
+@pytest.mark.filterwarnings(
+    "ignore:(Series|DataFrame).fillna with 'method' is deprecated:FutureWarning"
+)
+class TestSeriesFillNA:
+    def test_fillna_nat(self):
+        series = Series([0, 1, 2, NaT._value], dtype="M8[ns]")
+
+        filled = series.fillna(method="pad")
+        filled2 = series.fillna(value=series.values[2])
+
+        expected = series.copy()
+        expected.iloc[3] = expected.iloc[2]
+
+        tm.assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled2, expected)
+
+        df = DataFrame({"A": series})
+        filled = df.fillna(method="pad")
+        filled2 = df.fillna(value=series.values[2])
+        expected = DataFrame({"A": expected})
+        tm.assert_frame_equal(filled, expected)
+        tm.assert_frame_equal(filled2, expected)
+
+        series = Series([NaT._value, 0, 1, 2], dtype="M8[ns]")
+
+        filled = series.fillna(method="bfill")
+        filled2 = series.fillna(value=series[1])
+
+        expected = series.copy()
+        expected[0] = expected[1]
+
+        tm.assert_series_equal(filled, expected)
+        tm.assert_series_equal(filled2, expected)
+
+        df = DataFrame({"A": series})
+        filled = df.fillna(method="bfill")
+        filled2 = df.fillna(value=series[1])
+        expected = DataFrame({"A": expected})
+        tm.assert_frame_equal(filled, expected)
+        tm.assert_frame_equal(filled2, expected)
+
+    def test_fillna_value_or_method(self, datetime_series):
+        msg = "Cannot specify both 'value' and 'method'"
+        with pytest.raises(ValueError, match=msg):
+            datetime_series.fillna(value=0, method="ffill")
+
+    def test_fillna(self):
+        ts = Series([0.0, 1.0, 2.0, 3.0, 4.0], index=tm.makeDateIndex(5))
+
+        tm.assert_series_equal(ts, ts.fillna(method="ffill"))
+
+        ts.iloc[2] = np.nan
+
+        exp = Series([0.0, 1.0, 1.0, 3.0, 4.0], index=ts.index)
+        tm.assert_series_equal(ts.fillna(method="ffill"), exp)
+
+        exp = Series([0.0, 1.0, 3.0, 3.0, 4.0], index=ts.index)
+        tm.assert_series_equal(ts.fillna(method="backfill"), exp)
+
+        exp = Series([0.0, 1.0, 5.0, 3.0, 4.0], index=ts.index)
+        tm.assert_series_equal(ts.fillna(value=5), exp)
+
+        msg = "Must specify a fill 'value' or 'method'"
+        with pytest.raises(ValueError, match=msg):
+            ts.fillna()
+
+    def test_fillna_nonscalar(self):
+        # GH#5703
+        s1 = Series([np.nan])
+        s2 = Series([1])
+        result = s1.fillna(s2)
+        expected = Series([1.0])
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna({})
+        tm.assert_series_equal(result, s1)
+        result = s1.fillna(Series((), dtype=object))
+        tm.assert_series_equal(result, s1)
+        result = s2.fillna(s1)
+        tm.assert_series_equal(result, s2)
+        result = s1.fillna({0: 1})
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna({1: 1})
+        tm.assert_series_equal(result, Series([np.nan]))
+        result = s1.fillna({0: 1, 1: 1})
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna(Series({0: 1, 1: 1}))
+        tm.assert_series_equal(result, expected)
+        result = s1.fillna(Series({0: 1, 1: 1}, index=[4, 5]))
+        tm.assert_series_equal(result, s1)
+
+    def test_fillna_aligns(self):
+        s1 = Series([0, 1, 2], list("abc"))
+        s2 = Series([0, np.nan, 2], list("bac"))
+        result = s2.fillna(s1)
+        expected = Series([0, 0, 2.0], list("bac"))
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_limit(self):
+        ser = Series(np.nan, index=[0, 1, 2])
+        result = ser.fillna(999, limit=1)
+        expected = Series([999, np.nan, np.nan], index=[0, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.fillna(999, limit=2)
+        expected = Series([999, 999, np.nan], index=[0, 1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_dont_cast_strings(self):
+        # GH#9043
+        # make sure a string representation of int/float values can be filled
+        # correctly without raising errors or being converted
+        vals = ["0", "1.5", "-0.3"]
+        for val in vals:
+            ser = Series([0, 1, np.nan, np.nan, 4], dtype="float64")
+            result = ser.fillna(val)
+            expected = Series([0, 1, val, val, 4], dtype="object")
+            tm.assert_series_equal(result, expected)
+
+    def test_fillna_consistency(self):
+        # GH#16402
+        # fillna with a tz aware to a tz-naive, should result in object
+
+        ser = Series([Timestamp("20130101"), NaT])
+
+        result = ser.fillna(Timestamp("20130101", tz="US/Eastern"))
+        expected = Series(
+            [Timestamp("20130101"), Timestamp("2013-01-01", tz="US/Eastern")],
+            dtype="object",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = ser.where([True, False], Timestamp("20130101", tz="US/Eastern"))
+        tm.assert_series_equal(result, expected)
+
+        result = ser.where([True, False], Timestamp("20130101", tz="US/Eastern"))
+        tm.assert_series_equal(result, expected)
+
+        # with a non-datetime
+        result = ser.fillna("foo")
+        expected = Series([Timestamp("20130101"), "foo"])
+        tm.assert_series_equal(result, expected)
+
+        # assignment
+        ser2 = ser.copy()
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            ser2[1] = "foo"
+        tm.assert_series_equal(ser2, expected)
+
+    def test_fillna_downcast(self):
+        # GH#15277
+        # infer int64 from float64
+        ser = Series([1.0, np.nan])
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.fillna(0, downcast="infer")
+        expected = Series([1, 0])
+        tm.assert_series_equal(result, expected)
+
+        # infer int64 from float64 when fillna value is a dict
+        ser = Series([1.0, np.nan])
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.fillna({1: 0}, downcast="infer")
+        expected = Series([1, 0])
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_downcast_infer_objects_to_numeric(self):
+        # GH#44241 if we have object-dtype, 'downcast="infer"' should
+        #  _actually_ infer
+
+        arr = np.arange(5).astype(object)
+        arr[3] = np.nan
+
+        ser = Series(arr)
+
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.fillna(3, downcast="infer")
+        expected = Series(np.arange(5), dtype=np.int64)
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in ffill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.ffill(downcast="infer")
+        expected = Series([0, 1, 2, 2, 4], dtype=np.int64)
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in bfill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.bfill(downcast="infer")
+        expected = Series([0, 1, 2, 4, 4], dtype=np.int64)
+        tm.assert_series_equal(res, expected)
+
+        # with a non-round float present, we will downcast to float64
+        ser[2] = 2.5
+
+        expected = Series([0, 1, 2.5, 3, 4], dtype=np.float64)
+        msg = "The 'downcast' keyword in fillna is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.fillna(3, downcast="infer")
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in ffill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.ffill(downcast="infer")
+        expected = Series([0, 1, 2.5, 2.5, 4], dtype=np.float64)
+        tm.assert_series_equal(res, expected)
+
+        msg = "The 'downcast' keyword in bfill is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            res = ser.bfill(downcast="infer")
+        expected = Series([0, 1, 2.5, 4, 4], dtype=np.float64)
+        tm.assert_series_equal(res, expected)
+
+    def test_timedelta_fillna(self, frame_or_series):
+        # GH#3371
+        ser = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130102"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        td = ser.diff()
+        obj = frame_or_series(td)
+
+        # reg fillna
+        result = obj.fillna(Timedelta(seconds=0))
+        expected = Series(
+            [
+                timedelta(0),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ]
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        # GH#45746 pre-1.? ints were interpreted as seconds.  then that was
+        #  deprecated and changed to raise. In 2.0 it casts to common dtype,
+        #  consistent with every other dtype's behavior
+        res = obj.fillna(1)
+        expected = obj.astype(object).fillna(1)
+        tm.assert_equal(res, expected)
+
+        result = obj.fillna(Timedelta(seconds=1))
+        expected = Series(
+            [
+                timedelta(seconds=1),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ]
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(timedelta(days=1, seconds=1))
+        expected = Series(
+            [
+                timedelta(days=1, seconds=1),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ]
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(np.timedelta64(10**9))
+        expected = Series(
+            [
+                timedelta(seconds=1),
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ]
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(NaT)
+        expected = Series(
+            [
+                NaT,
+                timedelta(0),
+                timedelta(1),
+                timedelta(days=1, seconds=9 * 3600 + 60 + 1),
+            ],
+            dtype="m8[ns]",
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        # ffill
+        td[2] = np.nan
+        obj = frame_or_series(td)
+        result = obj.ffill()
+        expected = td.fillna(Timedelta(seconds=0))
+        expected[0] = np.nan
+        expected = frame_or_series(expected)
+
+        tm.assert_equal(result, expected)
+
+        # bfill
+        td[2] = np.nan
+        obj = frame_or_series(td)
+        result = obj.bfill()
+        expected = td.fillna(Timedelta(seconds=0))
+        expected[2] = timedelta(days=1, seconds=9 * 3600 + 60 + 1)
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+    def test_datetime64_fillna(self):
+        ser = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130102"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        ser[2] = np.nan
+
+        # ffill
+        result = ser.ffill()
+        expected = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+        # bfill
+        result = ser.bfill()
+        expected = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130103 9:01:01"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime64_fillna_backfill(self):
+        # GH#6587
+        # make sure that we are treating as integer when filling
+        ser = Series([NaT, NaT, "2013-08-05 15:30:00.000001"], dtype="M8[ns]")
+
+        expected = Series(
+            [
+                "2013-08-05 15:30:00.000001",
+                "2013-08-05 15:30:00.000001",
+                "2013-08-05 15:30:00.000001",
+            ],
+            dtype="M8[ns]",
+        )
+        result = ser.fillna(method="backfill")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "Asia/Tokyo"])
+    def test_datetime64_tz_fillna(self, tz):
+        # DatetimeLikeBlock
+        ser = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                NaT,
+                Timestamp("2011-01-03 10:00"),
+                NaT,
+            ]
+        )
+        null_loc = Series([False, True, False, True])
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00"),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-02 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        # check s is not changed
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-02 10:00", tz=tz),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna("AAA")
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                "AAA",
+                Timestamp("2011-01-03 10:00"),
+                "AAA",
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {
+                1: Timestamp("2011-01-02 10:00", tz=tz),
+                3: Timestamp("2011-01-04 10:00"),
+            }
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-04 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {1: Timestamp("2011-01-02 10:00"), 3: Timestamp("2011-01-04 10:00")}
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                Timestamp("2011-01-02 10:00"),
+                Timestamp("2011-01-03 10:00"),
+                Timestamp("2011-01-04 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        # DatetimeTZBlock
+        idx = DatetimeIndex(["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz=tz)
+        ser = Series(idx)
+        assert ser.dtype == f"datetime64[ns, {tz}]"
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00"),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz))
+        idx = DatetimeIndex(
+            [
+                "2011-01-01 10:00",
+                "2011-01-02 10:00",
+                "2011-01-03 10:00",
+                "2011-01-02 10:00",
+            ],
+            tz=tz,
+        )
+        expected = Series(idx)
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz).to_pydatetime())
+        idx = DatetimeIndex(
+            [
+                "2011-01-01 10:00",
+                "2011-01-02 10:00",
+                "2011-01-03 10:00",
+                "2011-01-02 10:00",
+            ],
+            tz=tz,
+        )
+        expected = Series(idx)
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna("AAA")
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                "AAA",
+                Timestamp("2011-01-03 10:00", tz=tz),
+                "AAA",
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {
+                1: Timestamp("2011-01-02 10:00", tz=tz),
+                3: Timestamp("2011-01-04 10:00"),
+            }
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2011-01-04 10:00"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        result = ser.fillna(
+            {
+                1: Timestamp("2011-01-02 10:00", tz=tz),
+                3: Timestamp("2011-01-04 10:00", tz=tz),
+            }
+        )
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2011-01-02 10:00", tz=tz),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2011-01-04 10:00", tz=tz),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        # filling with a naive/other zone, coerce to object
+        result = ser.fillna(Timestamp("20130101"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2013-01-01"),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2013-01-01"),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+        # pre-2.0 fillna with mixed tzs would cast to object, in 2.0
+        #  it retains dtype.
+        result = ser.fillna(Timestamp("20130101", tz="US/Pacific"))
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz=tz),
+                Timestamp("2013-01-01", tz="US/Pacific").tz_convert(tz),
+                Timestamp("2011-01-03 10:00", tz=tz),
+                Timestamp("2013-01-01", tz="US/Pacific").tz_convert(tz),
+            ]
+        )
+        tm.assert_series_equal(expected, result)
+        tm.assert_series_equal(isna(ser), null_loc)
+
+    def test_fillna_dt64tz_with_method(self):
+        # with timezone
+        # GH#15855
+        ser = Series([Timestamp("2012-11-11 00:00:00+01:00"), NaT])
+        exp = Series(
+            [
+                Timestamp("2012-11-11 00:00:00+01:00"),
+                Timestamp("2012-11-11 00:00:00+01:00"),
+            ]
+        )
+        tm.assert_series_equal(ser.fillna(method="pad"), exp)
+
+        ser = Series([NaT, Timestamp("2012-11-11 00:00:00+01:00")])
+        exp = Series(
+            [
+                Timestamp("2012-11-11 00:00:00+01:00"),
+                Timestamp("2012-11-11 00:00:00+01:00"),
+            ]
+        )
+        tm.assert_series_equal(ser.fillna(method="bfill"), exp)
+
+    def test_fillna_pytimedelta(self):
+        # GH#8209
+        ser = Series([np.nan, Timedelta("1 days")], index=["A", "B"])
+
+        result = ser.fillna(timedelta(1))
+        expected = Series(Timedelta("1 days"), index=["A", "B"])
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_period(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+
+        res = ser.fillna(Period("2012-01", freq="M"))
+        exp = Series([Period("2011-01", freq="M"), Period("2012-01", freq="M")])
+        tm.assert_series_equal(res, exp)
+        assert res.dtype == "Period[M]"
+
+    def test_fillna_dt64_timestamp(self, frame_or_series):
+        ser = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130102"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        ser[2] = np.nan
+        obj = frame_or_series(ser)
+
+        # reg fillna
+        result = obj.fillna(Timestamp("20130104"))
+        expected = Series(
+            [
+                Timestamp("20130101"),
+                Timestamp("20130101"),
+                Timestamp("20130104"),
+                Timestamp("20130103 9:01:01"),
+            ]
+        )
+        expected = frame_or_series(expected)
+        tm.assert_equal(result, expected)
+
+        result = obj.fillna(NaT)
+        expected = obj
+        tm.assert_equal(result, expected)
+
+    def test_fillna_dt64_non_nao(self):
+        # GH#27419
+        ser = Series([Timestamp("2010-01-01"), NaT, Timestamp("2000-01-01")])
+        val = np.datetime64("1975-04-05", "ms")
+
+        result = ser.fillna(val)
+        expected = Series(
+            [Timestamp("2010-01-01"), Timestamp("1975-04-05"), Timestamp("2000-01-01")]
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_numeric_inplace(self):
+        x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
+        y = x.copy()
+
+        return_value = y.fillna(value=0, inplace=True)
+        assert return_value is None
+
+        expected = x.fillna(value=0)
+        tm.assert_series_equal(y, expected)
+
+    # ---------------------------------------------------------------
+    # CategoricalDtype
+
+    @pytest.mark.parametrize(
+        "fill_value, expected_output",
+        [
+            ("a", ["a", "a", "b", "a", "a"]),
+            ({1: "a", 3: "b", 4: "b"}, ["a", "a", "b", "b", "b"]),
+            ({1: "a"}, ["a", "a", "b", np.nan, np.nan]),
+            ({1: "a", 3: "b"}, ["a", "a", "b", "b", np.nan]),
+            (Series("a"), ["a", np.nan, "b", np.nan, np.nan]),
+            (Series("a", index=[1]), ["a", "a", "b", np.nan, np.nan]),
+            (Series({1: "a", 3: "b"}), ["a", "a", "b", "b", np.nan]),
+            (Series(["a", "b"], index=[3, 4]), ["a", np.nan, "b", "a", "b"]),
+        ],
+    )
+    def test_fillna_categorical(self, fill_value, expected_output):
+        # GH#17033
+        # Test fillna for a Categorical series
+        data = ["a", np.nan, "b", np.nan, np.nan]
+        ser = Series(Categorical(data, categories=["a", "b"]))
+        exp = Series(Categorical(expected_output, categories=["a", "b"]))
+        result = ser.fillna(fill_value)
+        tm.assert_series_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "fill_value, expected_output",
+        [
+            (Series(["a", "b", "c", "d", "e"]), ["a", "b", "b", "d", "e"]),
+            (Series(["b", "d", "a", "d", "a"]), ["a", "d", "b", "d", "a"]),
+            (
+                Series(
+                    Categorical(
+                        ["b", "d", "a", "d", "a"], categories=["b", "c", "d", "e", "a"]
+                    )
+                ),
+                ["a", "d", "b", "d", "a"],
+            ),
+        ],
+    )
+    def test_fillna_categorical_with_new_categories(self, fill_value, expected_output):
+        # GH#26215
+        data = ["a", np.nan, "b", np.nan, np.nan]
+        ser = Series(Categorical(data, categories=["a", "b", "c", "d", "e"]))
+        exp = Series(Categorical(expected_output, categories=["a", "b", "c", "d", "e"]))
+        result = ser.fillna(fill_value)
+        tm.assert_series_equal(result, exp)
+
+    def test_fillna_categorical_raises(self):
+        data = ["a", np.nan, "b", np.nan, np.nan]
+        ser = Series(Categorical(data, categories=["a", "b"]))
+        cat = ser._values
+
+        msg = "Cannot setitem on a Categorical with a new category"
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna("d")
+
+        msg2 = "Length of 'value' does not match."
+        with pytest.raises(ValueError, match=msg2):
+            cat.fillna(Series("d"))
+
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna({1: "d", 3: "a"})
+
+        msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna(["a", "b"])
+
+        msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna(("a", "b"))
+
+        msg = (
+            '"value" parameter must be a scalar, dict '
+            'or Series, but you passed a "DataFrame"'
+        )
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna(DataFrame({1: ["a"], 3: ["b"]}))
+
+    @pytest.mark.parametrize("dtype", [float, "float32", "float64"])
+    @pytest.mark.parametrize("fill_type", tm.ALL_REAL_NUMPY_DTYPES)
+    @pytest.mark.parametrize("scalar", [True, False])
+    def test_fillna_float_casting(self, dtype, fill_type, scalar):
+        # GH-43424
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        fill_values = Series([2, 2], dtype=fill_type)
+        if scalar:
+            fill_values = fill_values.dtype.type(2)
+
+        result = ser.fillna(fill_values)
+        expected = Series([2.0, 1.2], dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        mask = ser.isna().to_numpy()
+        ser[mask] = fill_values
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        ser.mask(mask, fill_values, inplace=True)
+        tm.assert_series_equal(ser, expected)
+
+        ser = Series([np.nan, 1.2], dtype=dtype)
+        res = ser.where(~mask, fill_values)
+        tm.assert_series_equal(res, expected)
+
+    def test_fillna_f32_upcast_with_dict(self):
+        # GH-43424
+        ser = Series([np.nan, 1.2], dtype=np.float32)
+        result = ser.fillna({0: 1})
+        expected = Series([1.0, 1.2], dtype=np.float32)
+        tm.assert_series_equal(result, expected)
+
+    # ---------------------------------------------------------------
+    # Invalid Usages
+
+    def test_fillna_invalid_method(self, datetime_series):
+        try:
+            datetime_series.fillna(method="ffil")
+        except ValueError as inst:
+            assert "ffil" in str(inst)
+
+    def test_fillna_listlike_invalid(self):
+        ser = Series(np.random.default_rng(2).integers(-100, 100, 50))
+        msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna([1, 2])
+
+        msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
+        with pytest.raises(TypeError, match=msg):
+            ser.fillna((1, 2))
+
+    def test_fillna_method_and_limit_invalid(self):
+        # related GH#9217, make sure limit is an int and greater than 0
+        ser = Series([1, 2, 3, None])
+        msg = "|".join(
+            [
+                r"Cannot specify both 'value' and 'method'\.",
+                "Limit must be greater than 0",
+                "Limit must be an integer",
+            ]
+        )
+        for limit in [-1, 0, 1.0, 2.0]:
+            for method in ["backfill", "bfill", "pad", "ffill", None]:
+                with pytest.raises(ValueError, match=msg):
+                    ser.fillna(1, limit=limit, method=method)
+
+    def test_fillna_datetime64_with_timezone_tzinfo(self):
+        # https://github.com/pandas-dev/pandas/issues/38851
+        # different tzinfos representing UTC treated as equal
+        ser = Series(date_range("2020", periods=3, tz="UTC"))
+        expected = ser.copy()
+        ser[1] = NaT
+        result = ser.fillna(datetime(2020, 1, 2, tzinfo=timezone.utc))
+        tm.assert_series_equal(result, expected)
+
+        # pre-2.0 we cast to object with mixed tzs, in 2.0 we retain dtype
+        ts = Timestamp("2000-01-01", tz="US/Pacific")
+        ser2 = Series(ser._values.tz_convert("dateutil/US/Pacific"))
+        assert ser2.dtype.kind == "M"
+        result = ser2.fillna(ts)
+        expected = Series(
+            [ser2[0], ts.tz_convert(ser2.dtype.tz), ser2[2]],
+            dtype=ser2.dtype,
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "input, input_fillna, expected_data, expected_categories",
+        [
+            (["A", "B", None, "A"], "B", ["A", "B", "B", "A"], ["A", "B"]),
+            (["A", "B", np.nan, "A"], "B", ["A", "B", "B", "A"], ["A", "B"]),
+        ],
+    )
+    def test_fillna_categorical_accept_same_type(
+        self, input, input_fillna, expected_data, expected_categories
+    ):
+        # GH32414
+        cat = Categorical(input)
+        ser = Series(cat).fillna(input_fillna)
+        filled = cat.fillna(ser)
+        result = cat.fillna(filled)
+        expected = Categorical(expected_data, categories=expected_categories)
+        tm.assert_categorical_equal(result, expected)
+
+
+@pytest.mark.filterwarnings(
+    "ignore:Series.fillna with 'method' is deprecated:FutureWarning"
+)
+class TestFillnaPad:
+    def test_fillna_bug(self):
+        ser = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
+        filled = ser.fillna(method="ffill")
+        expected = Series([np.nan, 1.0, 1.0, 3.0, 3.0], ser.index)
+        tm.assert_series_equal(filled, expected)
+
+        filled = ser.fillna(method="bfill")
+        expected = Series([1.0, 1.0, 3.0, 3.0, np.nan], ser.index)
+        tm.assert_series_equal(filled, expected)
+
+    def test_ffill(self):
+        ts = Series([0.0, 1.0, 2.0, 3.0, 4.0], index=tm.makeDateIndex(5))
+        ts.iloc[2] = np.nan
+        tm.assert_series_equal(ts.ffill(), ts.fillna(method="ffill"))
+
+    def test_ffill_mixed_dtypes_without_missing_data(self):
+        # GH#14956
+        series = Series([datetime(2015, 1, 1, tzinfo=pytz.utc), 1])
+        result = series.ffill()
+        tm.assert_series_equal(series, result)
+
+    def test_bfill(self):
+        ts = Series([0.0, 1.0, 2.0, 3.0, 4.0], index=tm.makeDateIndex(5))
+        ts.iloc[2] = np.nan
+        tm.assert_series_equal(ts.bfill(), ts.fillna(method="bfill"))
+
+    def test_pad_nan(self):
+        x = Series(
+            [np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"], dtype=float
+        )
+
+        return_value = x.fillna(method="pad", inplace=True)
+        assert return_value is None
+
+        expected = Series(
+            [np.nan, 1.0, 1.0, 3.0, 3.0], ["z", "a", "b", "c", "d"], dtype=float
+        )
+        tm.assert_series_equal(x[1:], expected[1:])
+        assert np.isnan(x.iloc[0]), np.isnan(expected.iloc[0])
+
+    def test_series_fillna_limit(self):
+        index = np.arange(10)
+        s = Series(np.random.default_rng(2).standard_normal(10), index=index)
+
+        result = s[:2].reindex(index)
+        result = result.fillna(method="pad", limit=5)
+
+        expected = s[:2].reindex(index).fillna(method="pad")
+        expected[-3:] = np.nan
+        tm.assert_series_equal(result, expected)
+
+        result = s[-2:].reindex(index)
+        result = result.fillna(method="bfill", limit=5)
+
+        expected = s[-2:].reindex(index).fillna(method="backfill")
+        expected[:3] = np.nan
+        tm.assert_series_equal(result, expected)
+
+    def test_series_pad_backfill_limit(self):
+        index = np.arange(10)
+        s = Series(np.random.default_rng(2).standard_normal(10), index=index)
+
+        result = s[:2].reindex(index, method="pad", limit=5)
+
+        expected = s[:2].reindex(index).fillna(method="pad")
+        expected[-3:] = np.nan
+        tm.assert_series_equal(result, expected)
+
+        result = s[-2:].reindex(index, method="backfill", limit=5)
+
+        expected = s[-2:].reindex(index).fillna(method="backfill")
+        expected[:3] = np.nan
+        tm.assert_series_equal(result, expected)
+
+    def test_fillna_int(self):
+        ser = Series(np.random.default_rng(2).integers(-100, 100, 50))
+        return_value = ser.fillna(method="ffill", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(ser.fillna(method="ffill", inplace=False), ser)
+
+    def test_datetime64tz_fillna_round_issue(self):
+        # GH#14872
+
+        data = Series(
+            [NaT, NaT, datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc)]
+        )
+
+        filled = data.bfill()
+
+        expected = Series(
+            [
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+            ]
+        )
+
+        tm.assert_series_equal(filled, expected)
+
+    def test_fillna_parr(self):
+        # GH-24537
+        dti = date_range(
+            Timestamp.max - Timedelta(nanoseconds=10), periods=5, freq="ns"
+        )
+        ser = Series(dti.to_period("ns"))
+        ser[2] = NaT
+        arr = period_array(
+            [
+                Timestamp("2262-04-11 23:47:16.854775797"),
+                Timestamp("2262-04-11 23:47:16.854775798"),
+                Timestamp("2262-04-11 23:47:16.854775798"),
+                Timestamp("2262-04-11 23:47:16.854775800"),
+                Timestamp("2262-04-11 23:47:16.854775801"),
+            ],
+            freq="ns",
+        )
+        expected = Series(arr)
+
+        filled = ser.ffill()
+
+        tm.assert_series_equal(filled, expected)
+
+    @pytest.mark.parametrize("func", ["pad", "backfill"])
+    def test_pad_backfill_deprecated(self, func):
+        # GH#33396
+        ser = Series([1, 2, 3])
+        with tm.assert_produces_warning(FutureWarning):
+            getattr(ser, func)()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_get_numeric_data.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_get_numeric_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..11dc6d5c57162e47199c0fd6221e189877ec3ecf
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_get_numeric_data.py
@@ -0,0 +1,35 @@
+from pandas import (
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestGetNumericData:
+    def test_get_numeric_data_preserve_dtype(self, using_copy_on_write):
+        # get the numeric data
+        obj = Series([1, 2, 3])
+        result = obj._get_numeric_data()
+        tm.assert_series_equal(result, obj)
+
+        # returned object is a shallow copy
+        result.iloc[0] = 0
+        if using_copy_on_write:
+            assert obj.iloc[0] == 1
+        else:
+            assert obj.iloc[0] == 0
+
+        obj = Series([1, "2", 3.0])
+        result = obj._get_numeric_data()
+        expected = Series([], dtype=object, index=Index([], dtype=object))
+        tm.assert_series_equal(result, expected)
+
+        obj = Series([True, False, True])
+        result = obj._get_numeric_data()
+        tm.assert_series_equal(result, obj)
+
+        obj = Series(date_range("20130101", periods=3))
+        result = obj._get_numeric_data()
+        expected = Series([], dtype="M8[ns]", index=Index([], dtype=object))
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_head_tail.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_head_tail.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9f8d85eda350e0627790626d52b7703d23ead02
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_head_tail.py
@@ -0,0 +1,8 @@
+import pandas._testing as tm
+
+
+def test_head_tail(string_series):
+    tm.assert_series_equal(string_series.head(), string_series[:5])
+    tm.assert_series_equal(string_series.head(0), string_series[0:0])
+    tm.assert_series_equal(string_series.tail(), string_series[-5:])
+    tm.assert_series_equal(string_series.tail(0), string_series[0:0])
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_infer_objects.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_infer_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..25bff46d682be981bbafabe15c66c0e486c59be1
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_infer_objects.py
@@ -0,0 +1,56 @@
+import numpy as np
+
+from pandas import (
+    Series,
+    interval_range,
+)
+import pandas._testing as tm
+
+
+class TestInferObjects:
+    def test_copy(self, index_or_series):
+        # GH#50096
+        # case where we don't need to do inference because it is already non-object
+        obj = index_or_series(np.array([1, 2, 3], dtype="int64"))
+
+        result = obj.infer_objects(copy=False)
+        assert tm.shares_memory(result, obj)
+
+        # case where we try to do inference but can't do better than object
+        obj2 = index_or_series(np.array(["foo", 2], dtype=object))
+        result2 = obj2.infer_objects(copy=False)
+        assert tm.shares_memory(result2, obj2)
+
+    def test_infer_objects_series(self, index_or_series):
+        # GH#11221
+        actual = index_or_series(np.array([1, 2, 3], dtype="O")).infer_objects()
+        expected = index_or_series([1, 2, 3])
+        tm.assert_equal(actual, expected)
+
+        actual = index_or_series(np.array([1, 2, 3, None], dtype="O")).infer_objects()
+        expected = index_or_series([1.0, 2.0, 3.0, np.nan])
+        tm.assert_equal(actual, expected)
+
+        # only soft conversions, unconvertable pass thru unchanged
+
+        obj = index_or_series(np.array([1, 2, 3, None, "a"], dtype="O"))
+        actual = obj.infer_objects()
+        expected = index_or_series([1, 2, 3, None, "a"], dtype=object)
+
+        assert actual.dtype == "object"
+        tm.assert_equal(actual, expected)
+
+    def test_infer_objects_interval(self, index_or_series):
+        # GH#50090
+        ii = interval_range(1, 10)
+        obj = index_or_series(ii)
+
+        result = obj.astype(object).infer_objects()
+        tm.assert_equal(result, obj)
+
+    def test_infer_objects_bytes(self):
+        # GH#49650
+        ser = Series([b"a"], dtype="bytes")
+        expected = ser.copy()
+        result = ser.infer_objects()
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_interpolate.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_interpolate.py
new file mode 100644
index 0000000000000000000000000000000000000000..549f429f09d35270654f919630210015878ab1f4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_interpolate.py
@@ -0,0 +1,868 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    Index,
+    MultiIndex,
+    Series,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture(
+    params=[
+        "linear",
+        "index",
+        "values",
+        "nearest",
+        "slinear",
+        "zero",
+        "quadratic",
+        "cubic",
+        "barycentric",
+        "krogh",
+        "polynomial",
+        "spline",
+        "piecewise_polynomial",
+        "from_derivatives",
+        "pchip",
+        "akima",
+        "cubicspline",
+    ]
+)
+def nontemporal_method(request):
+    """Fixture that returns an (method name, required kwargs) pair.
+
+    This fixture does not include method 'time' as a parameterization; that
+    method requires a Series with a DatetimeIndex, and is generally tested
+    separately from these non-temporal methods.
+    """
+    method = request.param
+    kwargs = {"order": 1} if method in ("spline", "polynomial") else {}
+    return method, kwargs
+
+
+@pytest.fixture(
+    params=[
+        "linear",
+        "slinear",
+        "zero",
+        "quadratic",
+        "cubic",
+        "barycentric",
+        "krogh",
+        "polynomial",
+        "spline",
+        "piecewise_polynomial",
+        "from_derivatives",
+        "pchip",
+        "akima",
+        "cubicspline",
+    ]
+)
+def interp_methods_ind(request):
+    """Fixture that returns a (method name, required kwargs) pair to
+    be tested for various Index types.
+
+    This fixture does not include methods - 'time', 'index', 'nearest',
+    'values' as a parameterization
+    """
+    method = request.param
+    kwargs = {"order": 1} if method in ("spline", "polynomial") else {}
+    return method, kwargs
+
+
+class TestSeriesInterpolateData:
+    @pytest.mark.xfail(reason="EA.fillna does not handle 'linear' method")
+    def test_interpolate_period_values(self):
+        orig = Series(date_range("2012-01-01", periods=5))
+        ser = orig.copy()
+        ser[2] = pd.NaT
+
+        # period cast
+        ser_per = ser.dt.to_period("D")
+        res_per = ser_per.interpolate()
+        expected_per = orig.dt.to_period("D")
+        tm.assert_series_equal(res_per, expected_per)
+
+    def test_interpolate(self, datetime_series):
+        ts = Series(np.arange(len(datetime_series), dtype=float), datetime_series.index)
+
+        ts_copy = ts.copy()
+        ts_copy[5:10] = np.nan
+
+        linear_interp = ts_copy.interpolate(method="linear")
+        tm.assert_series_equal(linear_interp, ts)
+
+        ord_ts = Series(
+            [d.toordinal() for d in datetime_series.index], index=datetime_series.index
+        ).astype(float)
+
+        ord_ts_copy = ord_ts.copy()
+        ord_ts_copy[5:10] = np.nan
+
+        time_interp = ord_ts_copy.interpolate(method="time")
+        tm.assert_series_equal(time_interp, ord_ts)
+
+    def test_interpolate_time_raises_for_non_timeseries(self):
+        # When method='time' is used on a non-TimeSeries that contains a null
+        # value, a ValueError should be raised.
+        non_ts = Series([0, 1, 2, np.nan])
+        msg = "time-weighted interpolation only works on Series.* with a DatetimeIndex"
+        with pytest.raises(ValueError, match=msg):
+            non_ts.interpolate(method="time")
+
+    def test_interpolate_cubicspline(self):
+        pytest.importorskip("scipy")
+        ser = Series([10, 11, 12, 13])
+
+        expected = Series(
+            [11.00, 11.25, 11.50, 11.75, 12.00, 12.25, 12.50, 12.75, 13.00],
+            index=Index([1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]),
+        )
+        # interpolate at new_index
+        new_index = ser.index.union(Index([1.25, 1.5, 1.75, 2.25, 2.5, 2.75])).astype(
+            float
+        )
+        result = ser.reindex(new_index).interpolate(method="cubicspline").loc[1:3]
+        tm.assert_series_equal(result, expected)
+
+    def test_interpolate_pchip(self):
+        pytest.importorskip("scipy")
+        ser = Series(np.sort(np.random.default_rng(2).uniform(size=100)))
+
+        # interpolate at new_index
+        new_index = ser.index.union(
+            Index([49.25, 49.5, 49.75, 50.25, 50.5, 50.75])
+        ).astype(float)
+        interp_s = ser.reindex(new_index).interpolate(method="pchip")
+        # does not blow up, GH5977
+        interp_s.loc[49:51]
+
+    def test_interpolate_akima(self):
+        pytest.importorskip("scipy")
+        ser = Series([10, 11, 12, 13])
+
+        # interpolate at new_index where `der` is zero
+        expected = Series(
+            [11.00, 11.25, 11.50, 11.75, 12.00, 12.25, 12.50, 12.75, 13.00],
+            index=Index([1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]),
+        )
+        new_index = ser.index.union(Index([1.25, 1.5, 1.75, 2.25, 2.5, 2.75])).astype(
+            float
+        )
+        interp_s = ser.reindex(new_index).interpolate(method="akima")
+        tm.assert_series_equal(interp_s.loc[1:3], expected)
+
+        # interpolate at new_index where `der` is a non-zero int
+        expected = Series(
+            [11.0, 1.0, 1.0, 1.0, 12.0, 1.0, 1.0, 1.0, 13.0],
+            index=Index([1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]),
+        )
+        new_index = ser.index.union(Index([1.25, 1.5, 1.75, 2.25, 2.5, 2.75])).astype(
+            float
+        )
+        interp_s = ser.reindex(new_index).interpolate(method="akima", der=1)
+        tm.assert_series_equal(interp_s.loc[1:3], expected)
+
+    def test_interpolate_piecewise_polynomial(self):
+        pytest.importorskip("scipy")
+        ser = Series([10, 11, 12, 13])
+
+        expected = Series(
+            [11.00, 11.25, 11.50, 11.75, 12.00, 12.25, 12.50, 12.75, 13.00],
+            index=Index([1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]),
+        )
+        # interpolate at new_index
+        new_index = ser.index.union(Index([1.25, 1.5, 1.75, 2.25, 2.5, 2.75])).astype(
+            float
+        )
+        interp_s = ser.reindex(new_index).interpolate(method="piecewise_polynomial")
+        tm.assert_series_equal(interp_s.loc[1:3], expected)
+
+    def test_interpolate_from_derivatives(self):
+        pytest.importorskip("scipy")
+        ser = Series([10, 11, 12, 13])
+
+        expected = Series(
+            [11.00, 11.25, 11.50, 11.75, 12.00, 12.25, 12.50, 12.75, 13.00],
+            index=Index([1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]),
+        )
+        # interpolate at new_index
+        new_index = ser.index.union(Index([1.25, 1.5, 1.75, 2.25, 2.5, 2.75])).astype(
+            float
+        )
+        interp_s = ser.reindex(new_index).interpolate(method="from_derivatives")
+        tm.assert_series_equal(interp_s.loc[1:3], expected)
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            {},
+            pytest.param(
+                {"method": "polynomial", "order": 1}, marks=td.skip_if_no_scipy
+            ),
+        ],
+    )
+    def test_interpolate_corners(self, kwargs):
+        s = Series([np.nan, np.nan])
+        tm.assert_series_equal(s.interpolate(**kwargs), s)
+
+        s = Series([], dtype=object).interpolate()
+        tm.assert_series_equal(s.interpolate(**kwargs), s)
+
+    def test_interpolate_index_values(self):
+        s = Series(np.nan, index=np.sort(np.random.default_rng(2).random(30)))
+        s.loc[::3] = np.random.default_rng(2).standard_normal(10)
+
+        vals = s.index.values.astype(float)
+
+        result = s.interpolate(method="index")
+
+        expected = s.copy()
+        bad = isna(expected.values)
+        good = ~bad
+        expected = Series(
+            np.interp(vals[bad], vals[good], s.values[good]), index=s.index[bad]
+        )
+
+        tm.assert_series_equal(result[bad], expected)
+
+        # 'values' is synonymous with 'index' for the method kwarg
+        other_result = s.interpolate(method="values")
+
+        tm.assert_series_equal(other_result, result)
+        tm.assert_series_equal(other_result[bad], expected)
+
+    def test_interpolate_non_ts(self):
+        s = Series([1, 3, np.nan, np.nan, np.nan, 11])
+        msg = (
+            "time-weighted interpolation only works on Series or DataFrames "
+            "with a DatetimeIndex"
+        )
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method="time")
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            {},
+            pytest.param(
+                {"method": "polynomial", "order": 1}, marks=td.skip_if_no_scipy
+            ),
+        ],
+    )
+    def test_nan_interpolate(self, kwargs):
+        s = Series([0, 1, np.nan, 3])
+        result = s.interpolate(**kwargs)
+        expected = Series([0.0, 1.0, 2.0, 3.0])
+        tm.assert_series_equal(result, expected)
+
+    def test_nan_irregular_index(self):
+        s = Series([1, 2, np.nan, 4], index=[1, 3, 5, 9])
+        result = s.interpolate()
+        expected = Series([1.0, 2.0, 3.0, 4.0], index=[1, 3, 5, 9])
+        tm.assert_series_equal(result, expected)
+
+    def test_nan_str_index(self):
+        s = Series([0, 1, 2, np.nan], index=list("abcd"))
+        result = s.interpolate()
+        expected = Series([0.0, 1.0, 2.0, 2.0], index=list("abcd"))
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_quad(self):
+        pytest.importorskip("scipy")
+        sq = Series([1, 4, np.nan, 16], index=[1, 2, 3, 4])
+        result = sq.interpolate(method="quadratic")
+        expected = Series([1.0, 4.0, 9.0, 16.0], index=[1, 2, 3, 4])
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_scipy_basic(self):
+        pytest.importorskip("scipy")
+        s = Series([1, 3, np.nan, 12, np.nan, 25])
+        # slinear
+        expected = Series([1.0, 3.0, 7.5, 12.0, 18.5, 25.0])
+        result = s.interpolate(method="slinear")
+        tm.assert_series_equal(result, expected)
+
+        msg = "The 'downcast' keyword in Series.interpolate is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.interpolate(method="slinear", downcast="infer")
+        tm.assert_series_equal(result, expected)
+        # nearest
+        expected = Series([1, 3, 3, 12, 12, 25])
+        result = s.interpolate(method="nearest")
+        tm.assert_series_equal(result, expected.astype("float"))
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.interpolate(method="nearest", downcast="infer")
+        tm.assert_series_equal(result, expected)
+        # zero
+        expected = Series([1, 3, 3, 12, 12, 25])
+        result = s.interpolate(method="zero")
+        tm.assert_series_equal(result, expected.astype("float"))
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.interpolate(method="zero", downcast="infer")
+        tm.assert_series_equal(result, expected)
+        # quadratic
+        # GH #15662.
+        expected = Series([1, 3.0, 6.823529, 12.0, 18.058824, 25.0])
+        result = s.interpolate(method="quadratic")
+        tm.assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.interpolate(method="quadratic", downcast="infer")
+        tm.assert_series_equal(result, expected)
+        # cubic
+        expected = Series([1.0, 3.0, 6.8, 12.0, 18.2, 25.0])
+        result = s.interpolate(method="cubic")
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_limit(self):
+        s = Series([1, 3, np.nan, np.nan, np.nan, 11])
+
+        expected = Series([1.0, 3.0, 5.0, 7.0, np.nan, 11.0])
+        result = s.interpolate(method="linear", limit=2)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("limit", [-1, 0])
+    def test_interpolate_invalid_nonpositive_limit(self, nontemporal_method, limit):
+        # GH 9217: make sure limit is greater than zero.
+        s = Series([1, 2, np.nan, 4])
+        method, kwargs = nontemporal_method
+        with pytest.raises(ValueError, match="Limit must be greater than 0"):
+            s.interpolate(limit=limit, method=method, **kwargs)
+
+    def test_interpolate_invalid_float_limit(self, nontemporal_method):
+        # GH 9217: make sure limit is an integer.
+        s = Series([1, 2, np.nan, 4])
+        method, kwargs = nontemporal_method
+        limit = 2.0
+        with pytest.raises(ValueError, match="Limit must be an integer"):
+            s.interpolate(limit=limit, method=method, **kwargs)
+
+    @pytest.mark.parametrize("invalid_method", [None, "nonexistent_method"])
+    def test_interp_invalid_method(self, invalid_method):
+        s = Series([1, 3, np.nan, 12, np.nan, 25])
+
+        msg = f"method must be one of.* Got '{invalid_method}' instead"
+        if invalid_method is None:
+            msg = "'method' should be a string, not None"
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method=invalid_method)
+
+        # When an invalid method and invalid limit (such as -1) are
+        # provided, the error message reflects the invalid method.
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method=invalid_method, limit=-1)
+
+    def test_interp_invalid_method_and_value(self):
+        # GH#36624
+        ser = Series([1, 3, np.nan, 12, np.nan, 25])
+
+        msg = "'fill_value' is not a valid keyword for Series.interpolate"
+        msg2 = "Series.interpolate with method=pad"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                ser.interpolate(fill_value=3, method="pad")
+
+    def test_interp_limit_forward(self):
+        s = Series([1, 3, np.nan, np.nan, np.nan, 11])
+
+        # Provide 'forward' (the default) explicitly here.
+        expected = Series([1.0, 3.0, 5.0, 7.0, np.nan, 11.0])
+
+        result = s.interpolate(method="linear", limit=2, limit_direction="forward")
+        tm.assert_series_equal(result, expected)
+
+        result = s.interpolate(method="linear", limit=2, limit_direction="FORWARD")
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_unlimited(self):
+        # these test are for issue #16282 default Limit=None is unlimited
+        s = Series([np.nan, 1.0, 3.0, np.nan, np.nan, np.nan, 11.0, np.nan])
+        expected = Series([1.0, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 11.0])
+        result = s.interpolate(method="linear", limit_direction="both")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([np.nan, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 11.0])
+        result = s.interpolate(method="linear", limit_direction="forward")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([1.0, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, np.nan])
+        result = s.interpolate(method="linear", limit_direction="backward")
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_limit_bad_direction(self):
+        s = Series([1, 3, np.nan, np.nan, np.nan, 11])
+
+        msg = (
+            r"Invalid limit_direction: expecting one of \['forward', "
+            r"'backward', 'both'\], got 'abc'"
+        )
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method="linear", limit=2, limit_direction="abc")
+
+        # raises an error even if no limit is specified.
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method="linear", limit_direction="abc")
+
+    # limit_area introduced GH #16284
+    def test_interp_limit_area(self):
+        # These tests are for issue #9218 -- fill NaNs in both directions.
+        s = Series([np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan])
+
+        expected = Series([np.nan, np.nan, 3.0, 4.0, 5.0, 6.0, 7.0, np.nan, np.nan])
+        result = s.interpolate(method="linear", limit_area="inside")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series(
+            [np.nan, np.nan, 3.0, 4.0, np.nan, np.nan, 7.0, np.nan, np.nan]
+        )
+        result = s.interpolate(method="linear", limit_area="inside", limit=1)
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([np.nan, np.nan, 3.0, 4.0, np.nan, 6.0, 7.0, np.nan, np.nan])
+        result = s.interpolate(
+            method="linear", limit_area="inside", limit_direction="both", limit=1
+        )
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, 7.0])
+        result = s.interpolate(method="linear", limit_area="outside")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series(
+            [np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan]
+        )
+        result = s.interpolate(method="linear", limit_area="outside", limit=1)
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([np.nan, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan])
+        result = s.interpolate(
+            method="linear", limit_area="outside", limit_direction="both", limit=1
+        )
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([3.0, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan])
+        result = s.interpolate(
+            method="linear", limit_area="outside", limit_direction="backward"
+        )
+        tm.assert_series_equal(result, expected)
+
+        # raises an error even if limit type is wrong.
+        msg = r"Invalid limit_area: expecting one of \['inside', 'outside'\], got abc"
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method="linear", limit_area="abc")
+
+    @pytest.mark.parametrize(
+        "method, limit_direction, expected",
+        [
+            ("pad", "backward", "forward"),
+            ("ffill", "backward", "forward"),
+            ("backfill", "forward", "backward"),
+            ("bfill", "forward", "backward"),
+            ("pad", "both", "forward"),
+            ("ffill", "both", "forward"),
+            ("backfill", "both", "backward"),
+            ("bfill", "both", "backward"),
+        ],
+    )
+    def test_interp_limit_direction_raises(self, method, limit_direction, expected):
+        # https://github.com/pandas-dev/pandas/pull/34746
+        s = Series([1, 2, 3])
+
+        msg = f"`limit_direction` must be '{expected}' for method `{method}`"
+        msg2 = "Series.interpolate with method="
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                s.interpolate(method=method, limit_direction=limit_direction)
+
+    @pytest.mark.parametrize(
+        "data, expected_data, kwargs",
+        (
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, np.nan, 3.0, 3.0, 3.0, 3.0, 7.0, np.nan, np.nan],
+                {"method": "pad", "limit_area": "inside"},
+            ),
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, np.nan, 3.0, 3.0, np.nan, np.nan, 7.0, np.nan, np.nan],
+                {"method": "pad", "limit_area": "inside", "limit": 1},
+            ),
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, 7.0],
+                {"method": "pad", "limit_area": "outside"},
+            ),
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, np.nan, 3.0, np.nan, np.nan, np.nan, 7.0, 7.0, np.nan],
+                {"method": "pad", "limit_area": "outside", "limit": 1},
+            ),
+            (
+                [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+                [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+                {"method": "pad", "limit_area": "outside", "limit": 1},
+            ),
+            (
+                range(5),
+                range(5),
+                {"method": "pad", "limit_area": "outside", "limit": 1},
+            ),
+        ),
+    )
+    def test_interp_limit_area_with_pad(self, data, expected_data, kwargs):
+        # GH26796
+
+        s = Series(data)
+        expected = Series(expected_data)
+        msg = "Series.interpolate with method=pad"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.interpolate(**kwargs)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data, expected_data, kwargs",
+        (
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, np.nan, 3.0, 7.0, 7.0, 7.0, 7.0, np.nan, np.nan],
+                {"method": "bfill", "limit_area": "inside"},
+            ),
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, np.nan, 3.0, np.nan, np.nan, 7.0, 7.0, np.nan, np.nan],
+                {"method": "bfill", "limit_area": "inside", "limit": 1},
+            ),
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [3.0, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
+                {"method": "bfill", "limit_area": "outside"},
+            ),
+            (
+                [np.nan, np.nan, 3, np.nan, np.nan, np.nan, 7, np.nan, np.nan],
+                [np.nan, 3.0, 3.0, np.nan, np.nan, np.nan, 7.0, np.nan, np.nan],
+                {"method": "bfill", "limit_area": "outside", "limit": 1},
+            ),
+        ),
+    )
+    def test_interp_limit_area_with_backfill(self, data, expected_data, kwargs):
+        # GH26796
+
+        s = Series(data)
+        expected = Series(expected_data)
+        msg = "Series.interpolate with method=bfill"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = s.interpolate(**kwargs)
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_limit_direction(self):
+        # These tests are for issue #9218 -- fill NaNs in both directions.
+        s = Series([1, 3, np.nan, np.nan, np.nan, 11])
+
+        expected = Series([1.0, 3.0, np.nan, 7.0, 9.0, 11.0])
+        result = s.interpolate(method="linear", limit=2, limit_direction="backward")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([1.0, 3.0, 5.0, np.nan, 9.0, 11.0])
+        result = s.interpolate(method="linear", limit=1, limit_direction="both")
+        tm.assert_series_equal(result, expected)
+
+        # Check that this works on a longer series of nans.
+        s = Series([1, 3, np.nan, np.nan, np.nan, 7, 9, np.nan, np.nan, 12, np.nan])
+
+        expected = Series([1.0, 3.0, 4.0, 5.0, 6.0, 7.0, 9.0, 10.0, 11.0, 12.0, 12.0])
+        result = s.interpolate(method="linear", limit=2, limit_direction="both")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series(
+            [1.0, 3.0, 4.0, np.nan, 6.0, 7.0, 9.0, 10.0, 11.0, 12.0, 12.0]
+        )
+        result = s.interpolate(method="linear", limit=1, limit_direction="both")
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_limit_to_ends(self):
+        # These test are for issue #10420 -- flow back to beginning.
+        s = Series([np.nan, np.nan, 5, 7, 9, np.nan])
+
+        expected = Series([5.0, 5.0, 5.0, 7.0, 9.0, np.nan])
+        result = s.interpolate(method="linear", limit=2, limit_direction="backward")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([5.0, 5.0, 5.0, 7.0, 9.0, 9.0])
+        result = s.interpolate(method="linear", limit=2, limit_direction="both")
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_limit_before_ends(self):
+        # These test are for issue #11115 -- limit ends properly.
+        s = Series([np.nan, np.nan, 5, 7, np.nan, np.nan])
+
+        expected = Series([np.nan, np.nan, 5.0, 7.0, 7.0, np.nan])
+        result = s.interpolate(method="linear", limit=1, limit_direction="forward")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([np.nan, 5.0, 5.0, 7.0, np.nan, np.nan])
+        result = s.interpolate(method="linear", limit=1, limit_direction="backward")
+        tm.assert_series_equal(result, expected)
+
+        expected = Series([np.nan, 5.0, 5.0, 7.0, 7.0, np.nan])
+        result = s.interpolate(method="linear", limit=1, limit_direction="both")
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_all_good(self):
+        pytest.importorskip("scipy")
+        s = Series([1, 2, 3])
+        result = s.interpolate(method="polynomial", order=1)
+        tm.assert_series_equal(result, s)
+
+        # non-scipy
+        result = s.interpolate()
+        tm.assert_series_equal(result, s)
+
+    @pytest.mark.parametrize(
+        "check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
+    )
+    def test_interp_multiIndex(self, check_scipy):
+        idx = MultiIndex.from_tuples([(0, "a"), (1, "b"), (2, "c")])
+        s = Series([1, 2, np.nan], index=idx)
+
+        expected = s.copy()
+        expected.loc[2] = 2
+        result = s.interpolate()
+        tm.assert_series_equal(result, expected)
+
+        msg = "Only `method=linear` interpolation is supported on MultiIndexes"
+        if check_scipy:
+            with pytest.raises(ValueError, match=msg):
+                s.interpolate(method="polynomial", order=1)
+
+    def test_interp_nonmono_raise(self):
+        pytest.importorskip("scipy")
+        s = Series([1, np.nan, 3], index=[0, 2, 1])
+        msg = "krogh interpolation requires that the index be monotonic"
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method="krogh")
+
+    @pytest.mark.parametrize("method", ["nearest", "pad"])
+    def test_interp_datetime64(self, method, tz_naive_fixture):
+        pytest.importorskip("scipy")
+        df = Series(
+            [1, np.nan, 3], index=date_range("1/1/2000", periods=3, tz=tz_naive_fixture)
+        )
+        warn = None if method == "nearest" else FutureWarning
+        msg = "Series.interpolate with method=pad is deprecated"
+        with tm.assert_produces_warning(warn, match=msg):
+            result = df.interpolate(method=method)
+        if warn is not None:
+            # check the "use ffill instead" is equivalent
+            alt = df.ffill()
+            tm.assert_series_equal(result, alt)
+
+        expected = Series(
+            [1.0, 1.0, 3.0],
+            index=date_range("1/1/2000", periods=3, tz=tz_naive_fixture),
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_pad_datetime64tz_values(self):
+        # GH#27628 missing.interpolate_2d should handle datetimetz values
+        dti = date_range("2015-04-05", periods=3, tz="US/Central")
+        ser = Series(dti)
+        ser[1] = pd.NaT
+
+        msg = "Series.interpolate with method=pad is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.interpolate(method="pad")
+        # check the "use ffill instead" is equivalent
+        alt = ser.ffill()
+        tm.assert_series_equal(result, alt)
+
+        expected = Series(dti)
+        expected[1] = expected[0]
+        tm.assert_series_equal(result, expected)
+
+    def test_interp_limit_no_nans(self):
+        # GH 7173
+        s = Series([1.0, 2.0, 3.0])
+        result = s.interpolate(limit=1)
+        expected = s
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("method", ["polynomial", "spline"])
+    def test_no_order(self, method):
+        # see GH-10633, GH-24014
+        pytest.importorskip("scipy")
+        s = Series([0, 1, np.nan, 3])
+        msg = "You must specify the order of the spline or polynomial"
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method=method)
+
+    @pytest.mark.parametrize("order", [-1, -1.0, 0, 0.0, np.nan])
+    def test_interpolate_spline_invalid_order(self, order):
+        pytest.importorskip("scipy")
+        s = Series([0, 1, np.nan, 3])
+        msg = "order needs to be specified and greater than 0"
+        with pytest.raises(ValueError, match=msg):
+            s.interpolate(method="spline", order=order)
+
+    def test_spline(self):
+        pytest.importorskip("scipy")
+        s = Series([1, 2, np.nan, 4, 5, np.nan, 7])
+        result = s.interpolate(method="spline", order=1)
+        expected = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+        tm.assert_series_equal(result, expected)
+
+    def test_spline_extrapolate(self):
+        pytest.importorskip("scipy")
+        s = Series([1, 2, 3, 4, np.nan, 6, np.nan])
+        result3 = s.interpolate(method="spline", order=1, ext=3)
+        expected3 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 6.0])
+        tm.assert_series_equal(result3, expected3)
+
+        result1 = s.interpolate(method="spline", order=1, ext=0)
+        expected1 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+        tm.assert_series_equal(result1, expected1)
+
+    def test_spline_smooth(self):
+        pytest.importorskip("scipy")
+        s = Series([1, 2, np.nan, 4, 5.1, np.nan, 7])
+        assert (
+            s.interpolate(method="spline", order=3, s=0)[5]
+            != s.interpolate(method="spline", order=3)[5]
+        )
+
+    def test_spline_interpolation(self):
+        # Explicit cast to float to avoid implicit cast when setting np.nan
+        pytest.importorskip("scipy")
+        s = Series(np.arange(10) ** 2, dtype="float")
+        s[np.random.default_rng(2).integers(0, 9, 3)] = np.nan
+        result1 = s.interpolate(method="spline", order=1)
+        expected1 = s.interpolate(method="spline", order=1)
+        tm.assert_series_equal(result1, expected1)
+
+    def test_interp_timedelta64(self):
+        # GH 6424
+        df = Series([1, np.nan, 3], index=pd.to_timedelta([1, 2, 3]))
+        result = df.interpolate(method="time")
+        expected = Series([1.0, 2.0, 3.0], index=pd.to_timedelta([1, 2, 3]))
+        tm.assert_series_equal(result, expected)
+
+        # test for non uniform spacing
+        df = Series([1, np.nan, 3], index=pd.to_timedelta([1, 2, 4]))
+        result = df.interpolate(method="time")
+        expected = Series([1.0, 1.666667, 3.0], index=pd.to_timedelta([1, 2, 4]))
+        tm.assert_series_equal(result, expected)
+
+    def test_series_interpolate_method_values(self):
+        # GH#1646
+        rng = date_range("1/1/2000", "1/20/2000", freq="D")
+        ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
+
+        ts[::2] = np.nan
+
+        result = ts.interpolate(method="values")
+        exp = ts.interpolate()
+        tm.assert_series_equal(result, exp)
+
+    def test_series_interpolate_intraday(self):
+        # #1698
+        index = date_range("1/1/2012", periods=4, freq="12D")
+        ts = Series([0, 12, 24, 36], index)
+        new_index = index.append(index + pd.DateOffset(days=1)).sort_values()
+
+        exp = ts.reindex(new_index).interpolate(method="time")
+
+        index = date_range("1/1/2012", periods=4, freq="12H")
+        ts = Series([0, 12, 24, 36], index)
+        new_index = index.append(index + pd.DateOffset(hours=1)).sort_values()
+        result = ts.reindex(new_index).interpolate(method="time")
+
+        tm.assert_numpy_array_equal(result.values, exp.values)
+
+    @pytest.mark.parametrize(
+        "ind",
+        [
+            ["a", "b", "c", "d"],
+            pd.period_range(start="2019-01-01", periods=4),
+            pd.interval_range(start=0, end=4),
+        ],
+    )
+    def test_interp_non_timedelta_index(self, interp_methods_ind, ind):
+        # gh 21662
+        df = pd.DataFrame([0, 1, np.nan, 3], index=ind)
+
+        method, kwargs = interp_methods_ind
+        if method == "pchip":
+            pytest.importorskip("scipy")
+
+        if method == "linear":
+            result = df[0].interpolate(**kwargs)
+            expected = Series([0.0, 1.0, 2.0, 3.0], name=0, index=ind)
+            tm.assert_series_equal(result, expected)
+        else:
+            expected_error = (
+                "Index column must be numeric or datetime type when "
+                f"using {method} method other than linear. "
+                "Try setting a numeric or datetime index column before "
+                "interpolating."
+            )
+            with pytest.raises(ValueError, match=expected_error):
+                df[0].interpolate(method=method, **kwargs)
+
+    def test_interpolate_timedelta_index(self, request, interp_methods_ind):
+        """
+        Tests for non numerical index types  - object, period, timedelta
+        Note that all methods except time, index, nearest and values
+        are tested here.
+        """
+        # gh 21662
+        pytest.importorskip("scipy")
+        ind = pd.timedelta_range(start=1, periods=4)
+        df = pd.DataFrame([0, 1, np.nan, 3], index=ind)
+
+        method, kwargs = interp_methods_ind
+
+        if method in {"cubic", "zero"}:
+            request.node.add_marker(
+                pytest.mark.xfail(
+                    reason=f"{method} interpolation is not supported for TimedeltaIndex"
+                )
+            )
+        result = df[0].interpolate(method=method, **kwargs)
+        expected = Series([0.0, 1.0, 2.0, 3.0], name=0, index=ind)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ascending, expected_values",
+        [(True, [1, 2, 3, 9, 10]), (False, [10, 9, 3, 2, 1])],
+    )
+    def test_interpolate_unsorted_index(self, ascending, expected_values):
+        # GH 21037
+        ts = Series(data=[10, 9, np.nan, 2, 1], index=[10, 9, 3, 2, 1])
+        result = ts.sort_index(ascending=ascending).interpolate(method="index")
+        expected = Series(data=expected_values, index=expected_values, dtype=float)
+        tm.assert_series_equal(result, expected)
+
+    def test_interpolate_asfreq_raises(self):
+        ser = Series(["a", None, "b"], dtype=object)
+        msg2 = "Series.interpolate with object dtype"
+        msg = "Invalid fill method"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                ser.interpolate(method="asfreq")
+
+    def test_interpolate_fill_value(self):
+        # GH#54920
+        pytest.importorskip("scipy")
+        ser = Series([np.nan, 0, 1, np.nan, 3, np.nan])
+        result = ser.interpolate(method="nearest", fill_value=0)
+        expected = Series([np.nan, 0, 1, 1, 3, 0])
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_is_monotonic.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_is_monotonic.py
new file mode 100644
index 0000000000000000000000000000000000000000..073ec4172aff6b041d29011bc3151f84f3cbeb19
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_is_monotonic.py
@@ -0,0 +1,26 @@
+import numpy as np
+
+from pandas import (
+    Series,
+    date_range,
+)
+
+
+class TestIsMonotonic:
+    def test_is_monotonic_numeric(self):
+        ser = Series(np.random.default_rng(2).integers(0, 10, size=1000))
+        assert not ser.is_monotonic_increasing
+        ser = Series(np.arange(1000))
+        assert ser.is_monotonic_increasing is True
+        assert ser.is_monotonic_increasing is True
+        ser = Series(np.arange(1000, 0, -1))
+        assert ser.is_monotonic_decreasing is True
+
+    def test_is_monotonic_dt64(self):
+        ser = Series(date_range("20130101", periods=10))
+        assert ser.is_monotonic_increasing is True
+        assert ser.is_monotonic_increasing is True
+
+        ser = Series(list(reversed(ser)))
+        assert ser.is_monotonic_increasing is False
+        assert ser.is_monotonic_decreasing is True
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_is_unique.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_is_unique.py
new file mode 100644
index 0000000000000000000000000000000000000000..edf3839c2cebb6f51d0bb21b06ea8a1c47dec0fe
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_is_unique.py
@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+
+
+@pytest.mark.parametrize(
+    "data, expected",
+    [
+        (np.random.default_rng(2).integers(0, 10, size=1000), False),
+        (np.arange(1000), True),
+        ([], True),
+        ([np.nan], True),
+        (["foo", "bar", np.nan], True),
+        (["foo", "foo", np.nan], False),
+        (["foo", "bar", np.nan, np.nan], False),
+    ],
+)
+def test_is_unique(data, expected):
+    # GH#11946 / GH#25180
+    ser = Series(data)
+    assert ser.is_unique is expected
+
+
+def test_is_unique_class_ne(capsys):
+    # GH#20661
+    class Foo:
+        def __init__(self, val) -> None:
+            self._value = val
+
+        def __ne__(self, other):
+            raise Exception("NEQ not supported")
+
+    with capsys.disabled():
+        li = [Foo(i) for i in range(5)]
+        ser = Series(li, index=list(range(5)))
+
+    ser.is_unique
+    captured = capsys.readouterr()
+    assert len(captured.err) == 0
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_isin.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_isin.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ea2fbf51afc949b96d49669ce6fe5a17ab5796a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_isin.py
@@ -0,0 +1,248 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import PeriodArray
+
+
+class TestSeriesIsIn:
+    def test_isin(self):
+        s = Series(["A", "B", "C", "a", "B", "B", "A", "C"])
+
+        result = s.isin(["A", "C"])
+        expected = Series([True, False, True, False, False, False, True, True])
+        tm.assert_series_equal(result, expected)
+
+        # GH#16012
+        # This specific issue has to have a series over 1e6 in len, but the
+        # comparison array (in_list) must be large enough so that numpy doesn't
+        # do a manual masking trick that will avoid this issue altogether
+        s = Series(list("abcdefghijk" * 10**5))
+        # If numpy doesn't do the manual comparison/mask, these
+        # unorderable mixed types are what cause the exception in numpy
+        in_list = [-1, "a", "b", "G", "Y", "Z", "E", "K", "E", "S", "I", "R", "R"] * 6
+
+        assert s.isin(in_list).sum() == 200000
+
+    def test_isin_with_string_scalar(self):
+        # GH#4763
+        s = Series(["A", "B", "C", "a", "B", "B", "A", "C"])
+        msg = (
+            r"only list-like objects are allowed to be passed to isin\(\), "
+            r"you passed a `str`"
+        )
+        with pytest.raises(TypeError, match=msg):
+            s.isin("a")
+
+        s = Series(["aaa", "b", "c"])
+        with pytest.raises(TypeError, match=msg):
+            s.isin("aaa")
+
+    def test_isin_datetimelike_mismatched_reso(self):
+        expected = Series([True, True, False, False, False])
+
+        ser = Series(date_range("jan-01-2013", "jan-05-2013"))
+
+        # fails on dtype conversion in the first place
+        day_values = np.asarray(ser[0:2].values).astype("datetime64[D]")
+        result = ser.isin(day_values)
+        tm.assert_series_equal(result, expected)
+
+        dta = ser[:2]._values.astype("M8[s]")
+        result = ser.isin(dta)
+        tm.assert_series_equal(result, expected)
+
+    def test_isin_datetimelike_mismatched_reso_list(self):
+        expected = Series([True, True, False, False, False])
+
+        ser = Series(date_range("jan-01-2013", "jan-05-2013"))
+
+        dta = ser[:2]._values.astype("M8[s]")
+        result = ser.isin(list(dta))
+        tm.assert_series_equal(result, expected)
+
+    def test_isin_with_i8(self):
+        # GH#5021
+
+        expected = Series([True, True, False, False, False])
+        expected2 = Series([False, True, False, False, False])
+
+        # datetime64[ns]
+        s = Series(date_range("jan-01-2013", "jan-05-2013"))
+
+        result = s.isin(s[0:2])
+        tm.assert_series_equal(result, expected)
+
+        result = s.isin(s[0:2].values)
+        tm.assert_series_equal(result, expected)
+
+        result = s.isin([s[1]])
+        tm.assert_series_equal(result, expected2)
+
+        result = s.isin([np.datetime64(s[1])])
+        tm.assert_series_equal(result, expected2)
+
+        result = s.isin(set(s[0:2]))
+        tm.assert_series_equal(result, expected)
+
+        # timedelta64[ns]
+        s = Series(pd.to_timedelta(range(5), unit="d"))
+        result = s.isin(s[0:2])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
+    def test_isin_empty(self, empty):
+        # see GH#16991
+        s = Series(["a", "b"])
+        expected = Series([False, False])
+
+        result = s.isin(empty)
+        tm.assert_series_equal(expected, result)
+
+    def test_isin_read_only(self):
+        # https://github.com/pandas-dev/pandas/issues/37174
+        arr = np.array([1, 2, 3])
+        arr.setflags(write=False)
+        s = Series([1, 2, 3])
+        result = s.isin(arr)
+        expected = Series([True, True, True])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", [object, None])
+    def test_isin_dt64_values_vs_ints(self, dtype):
+        # GH#36621 dont cast integers to datetimes for isin
+        dti = date_range("2013-01-01", "2013-01-05")
+        ser = Series(dti)
+
+        comps = np.asarray([1356998400000000000], dtype=dtype)
+
+        res = dti.isin(comps)
+        expected = np.array([False] * len(dti), dtype=bool)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = ser.isin(comps)
+        tm.assert_series_equal(res, Series(expected))
+
+        res = pd.core.algorithms.isin(ser, comps)
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_isin_tzawareness_mismatch(self):
+        dti = date_range("2013-01-01", "2013-01-05")
+        ser = Series(dti)
+
+        other = dti.tz_localize("UTC")
+
+        res = dti.isin(other)
+        expected = np.array([False] * len(dti), dtype=bool)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = ser.isin(other)
+        tm.assert_series_equal(res, Series(expected))
+
+        res = pd.core.algorithms.isin(ser, other)
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_isin_period_freq_mismatch(self):
+        dti = date_range("2013-01-01", "2013-01-05")
+        pi = dti.to_period("M")
+        ser = Series(pi)
+
+        # We construct another PeriodIndex with the same i8 values
+        #  but different dtype
+        dtype = dti.to_period("Y").dtype
+        other = PeriodArray._simple_new(pi.asi8, dtype=dtype)
+
+        res = pi.isin(other)
+        expected = np.array([False] * len(pi), dtype=bool)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = ser.isin(other)
+        tm.assert_series_equal(res, Series(expected))
+
+        res = pd.core.algorithms.isin(ser, other)
+        tm.assert_numpy_array_equal(res, expected)
+
+    @pytest.mark.parametrize("values", [[-9.0, 0.0], [-9, 0]])
+    def test_isin_float_in_int_series(self, values):
+        # GH#19356 GH#21804
+        ser = Series(values)
+        result = ser.isin([-9, -0.5])
+        expected = Series([True, False])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("dtype", ["boolean", "Int64", "Float64"])
+    @pytest.mark.parametrize(
+        "data,values,expected",
+        [
+            ([0, 1, 0], [1], [False, True, False]),
+            ([0, 1, 0], [1, pd.NA], [False, True, False]),
+            ([0, pd.NA, 0], [1, 0], [True, False, True]),
+            ([0, 1, pd.NA], [1, pd.NA], [False, True, True]),
+            ([0, 1, pd.NA], [1, np.nan], [False, True, False]),
+            ([0, pd.NA, pd.NA], [np.nan, pd.NaT, None], [False, False, False]),
+        ],
+    )
+    def test_isin_masked_types(self, dtype, data, values, expected):
+        # GH#42405
+        ser = Series(data, dtype=dtype)
+
+        result = ser.isin(values)
+        expected = Series(expected, dtype="boolean")
+
+        tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.slow
+def test_isin_large_series_mixed_dtypes_and_nan():
+    # https://github.com/pandas-dev/pandas/issues/37094
+    # combination of object dtype for the values and > 1_000_000 elements
+    ser = Series([1, 2, np.nan] * 1_000_000)
+    result = ser.isin({"foo", "bar"})
+    expected = Series([False] * 3 * 1_000_000)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "array,expected",
+    [
+        (
+            [0, 1j, 1j, 1, 1 + 1j, 1 + 2j, 1 + 1j],
+            Series([False, True, True, False, True, True, True], dtype=bool),
+        )
+    ],
+)
+def test_isin_complex_numbers(array, expected):
+    # GH 17927
+    result = Series(array).isin([1j, 1 + 1j, 1 + 2j])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data,is_in",
+    [([1, [2]], [1]), (["simple str", [{"values": 3}]], ["simple str"])],
+)
+def test_isin_filtering_with_mixed_object_types(data, is_in):
+    # GH 20883
+
+    ser = Series(data)
+    result = ser.isin(is_in)
+    expected = Series([True, False])
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("data", [[1, 2, 3], [1.0, 2.0, 3.0]])
+@pytest.mark.parametrize("isin", [[1, 2], [1.0, 2.0]])
+def test_isin_filtering_on_iterable(data, isin):
+    # GH 50234
+
+    ser = Series(data)
+    result = ser.isin(i for i in isin)
+    expected_result = Series([True, True, False])
+
+    tm.assert_series_equal(result, expected_result)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_isna.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_isna.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e324aa86a052246a074950082e272fee7e505e3
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_isna.py
@@ -0,0 +1,35 @@
+"""
+We also test Series.notna in this file.
+"""
+import numpy as np
+
+from pandas import (
+    Period,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestIsna:
+    def test_isna_period_dtype(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+
+        expected = Series([False, True])
+
+        result = ser.isna()
+        tm.assert_series_equal(result, expected)
+
+        result = ser.notna()
+        tm.assert_series_equal(result, ~expected)
+
+    def test_isna(self):
+        ser = Series([0, 5.4, 3, np.nan, -0.001])
+        expected = Series([False, False, False, True, False])
+        tm.assert_series_equal(ser.isna(), expected)
+        tm.assert_series_equal(ser.notna(), ~expected)
+
+        ser = Series(["hi", "", np.nan])
+        expected = Series([False, False, True])
+        tm.assert_series_equal(ser.isna(), expected)
+        tm.assert_series_equal(ser.notna(), ~expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_item.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_item.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e8c33619d564ef87d51416748b8fdc9058e5a41
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_item.py
@@ -0,0 +1,59 @@
+"""
+Series.item method, mainly testing that we get python scalars as opposed to
+numpy scalars.
+"""
+import pytest
+
+from pandas import (
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+
+
+class TestItem:
+    def test_item(self):
+        # We are testing that we get python scalars as opposed to numpy scalars
+        ser = Series([1])
+        result = ser.item()
+        assert result == 1
+        assert result == ser.iloc[0]
+        assert isinstance(result, int)  # i.e. not np.int64
+
+        ser = Series([0.5], index=[3])
+        result = ser.item()
+        assert isinstance(result, float)
+        assert result == 0.5
+
+        ser = Series([1, 2])
+        msg = "can only convert an array of size 1"
+        with pytest.raises(ValueError, match=msg):
+            ser.item()
+
+        dti = date_range("2016-01-01", periods=2)
+        with pytest.raises(ValueError, match=msg):
+            dti.item()
+        with pytest.raises(ValueError, match=msg):
+            Series(dti).item()
+
+        val = dti[:1].item()
+        assert isinstance(val, Timestamp)
+        val = Series(dti)[:1].item()
+        assert isinstance(val, Timestamp)
+
+        tdi = dti - dti
+        with pytest.raises(ValueError, match=msg):
+            tdi.item()
+        with pytest.raises(ValueError, match=msg):
+            Series(tdi).item()
+
+        val = tdi[:1].item()
+        assert isinstance(val, Timedelta)
+        val = Series(tdi)[:1].item()
+        assert isinstance(val, Timedelta)
+
+        # Case where ser[0] would not work
+        ser = Series(dti, index=[5, 6])
+        val = ser.iloc[:1].item()
+        assert val == dti[0]
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_map.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..783e18e541ad8bea4b223f4e249da82f93ca606d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_map.py
@@ -0,0 +1,576 @@
+from collections import (
+    Counter,
+    defaultdict,
+)
+from decimal import Decimal
+import math
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    isna,
+    timedelta_range,
+)
+import pandas._testing as tm
+
+
+def test_series_map_box_timedelta():
+    # GH#11349
+    ser = Series(timedelta_range("1 day 1 s", periods=5, freq="h"))
+
+    def f(x):
+        return x.total_seconds()
+
+    ser.map(f)
+
+
+def test_map_callable(datetime_series):
+    with np.errstate(all="ignore"):
+        tm.assert_series_equal(datetime_series.map(np.sqrt), np.sqrt(datetime_series))
+
+    # map function element-wise
+    tm.assert_series_equal(datetime_series.map(math.exp), np.exp(datetime_series))
+
+    # empty series
+    s = Series(dtype=object, name="foo", index=Index([], name="bar"))
+    rs = s.map(lambda x: x)
+    tm.assert_series_equal(s, rs)
+
+    # check all metadata (GH 9322)
+    assert s is not rs
+    assert s.index is rs.index
+    assert s.dtype == rs.dtype
+    assert s.name == rs.name
+
+    # index but no data
+    s = Series(index=[1, 2, 3], dtype=np.float64)
+    rs = s.map(lambda x: x)
+    tm.assert_series_equal(s, rs)
+
+
+def test_map_same_length_inference_bug():
+    s = Series([1, 2])
+
+    def f(x):
+        return (x, x + 1)
+
+    s = Series([1, 2, 3])
+    result = s.map(f)
+    expected = Series([(1, 2), (2, 3), (3, 4)])
+    tm.assert_series_equal(result, expected)
+
+    s = Series(["foo,bar"])
+    result = s.map(lambda x: x.split(","))
+    expected = Series([("foo", "bar")])
+    tm.assert_series_equal(result, expected)
+
+
+def test_series_map_box_timestamps():
+    # GH#2689, GH#2627
+    ser = Series(pd.date_range("1/1/2000", periods=3))
+
+    def func(x):
+        return (x.hour, x.day, x.month)
+
+    result = ser.map(func)
+    expected = Series([(0, 1, 1), (0, 2, 1), (0, 3, 1)])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_series_stringdtype(any_string_dtype):
+    # map test on StringDType, GH#40823
+    ser1 = Series(
+        data=["cat", "dog", "rabbit"],
+        index=["id1", "id2", "id3"],
+        dtype=any_string_dtype,
+    )
+    ser2 = Series(["id3", "id2", "id1", "id7000"], dtype=any_string_dtype)
+    result = ser2.map(ser1)
+
+    item = pd.NA
+    if ser2.dtype == object:
+        item = np.nan
+
+    expected = Series(data=["rabbit", "dog", "cat", item], dtype=any_string_dtype)
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, expected_dtype",
+    [(["1-1", "1-1", np.nan], "category"), (["1-1", "1-2", np.nan], object)],
+)
+def test_map_categorical_with_nan_values(data, expected_dtype):
+    # GH 20714 bug fixed in: GH 24275
+    def func(val):
+        return val.split("-")[0]
+
+    s = Series(data, dtype="category")
+
+    result = s.map(func, na_action="ignore")
+    expected = Series(["1", "1", np.nan], dtype=expected_dtype)
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_empty_integer_series():
+    # GH52384
+    s = Series([], dtype=int)
+    result = s.map(lambda x: x)
+    tm.assert_series_equal(result, s)
+
+
+def test_map_empty_integer_series_with_datetime_index():
+    # GH 21245
+    s = Series([], index=pd.date_range(start="2018-01-01", periods=0), dtype=int)
+    result = s.map(lambda x: x)
+    tm.assert_series_equal(result, s)
+
+
+@pytest.mark.parametrize("func", [str, lambda x: str(x)])
+def test_map_simple_str_callables_same_as_astype(string_series, func):
+    # test that we are evaluating row-by-row first
+    # before vectorized evaluation
+    result = string_series.map(func)
+    expected = string_series.astype(str)
+    tm.assert_series_equal(result, expected)
+
+
+def test_list_raises(string_series):
+    with pytest.raises(TypeError, match="'list' object is not callable"):
+        string_series.map([lambda x: x])
+
+
+def test_map(datetime_series):
+    index, data = tm.getMixedTypeDict()
+
+    source = Series(data["B"], index=data["C"])
+    target = Series(data["C"][:4], index=data["D"][:4])
+
+    merged = target.map(source)
+
+    for k, v in merged.items():
+        assert v == source[target[k]]
+
+    # input could be a dict
+    merged = target.map(source.to_dict())
+
+    for k, v in merged.items():
+        assert v == source[target[k]]
+
+    # function
+    result = datetime_series.map(lambda x: x * 2)
+    tm.assert_series_equal(result, datetime_series * 2)
+
+    # GH 10324
+    a = Series([1, 2, 3, 4])
+    b = Series(["even", "odd", "even", "odd"], dtype="category")
+    c = Series(["even", "odd", "even", "odd"])
+
+    exp = Series(["odd", "even", "odd", np.nan], dtype="category")
+    tm.assert_series_equal(a.map(b), exp)
+    exp = Series(["odd", "even", "odd", np.nan])
+    tm.assert_series_equal(a.map(c), exp)
+
+    a = Series(["a", "b", "c", "d"])
+    b = Series([1, 2, 3, 4], index=pd.CategoricalIndex(["b", "c", "d", "e"]))
+    c = Series([1, 2, 3, 4], index=Index(["b", "c", "d", "e"]))
+
+    exp = Series([np.nan, 1, 2, 3])
+    tm.assert_series_equal(a.map(b), exp)
+    exp = Series([np.nan, 1, 2, 3])
+    tm.assert_series_equal(a.map(c), exp)
+
+    a = Series(["a", "b", "c", "d"])
+    b = Series(
+        ["B", "C", "D", "E"],
+        dtype="category",
+        index=pd.CategoricalIndex(["b", "c", "d", "e"]),
+    )
+    c = Series(["B", "C", "D", "E"], index=Index(["b", "c", "d", "e"]))
+
+    exp = Series(
+        pd.Categorical([np.nan, "B", "C", "D"], categories=["B", "C", "D", "E"])
+    )
+    tm.assert_series_equal(a.map(b), exp)
+    exp = Series([np.nan, "B", "C", "D"])
+    tm.assert_series_equal(a.map(c), exp)
+
+
+def test_map_empty(request, index):
+    if isinstance(index, MultiIndex):
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="Initializing a Series from a MultiIndex is not supported"
+            )
+        )
+
+    s = Series(index)
+    result = s.map({})
+
+    expected = Series(np.nan, index=s.index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_compat():
+    # related GH 8024
+    s = Series([True, True, False], index=[1, 2, 3])
+    result = s.map({True: "foo", False: "bar"})
+    expected = Series(["foo", "foo", "bar"], index=[1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_int():
+    left = Series({"a": 1.0, "b": 2.0, "c": 3.0, "d": 4})
+    right = Series({1: 11, 2: 22, 3: 33})
+
+    assert left.dtype == np.float64
+    assert issubclass(right.dtype.type, np.integer)
+
+    merged = left.map(right)
+    assert merged.dtype == np.float64
+    assert isna(merged["d"])
+    assert not isna(merged["c"])
+
+
+def test_map_type_inference():
+    s = Series(range(3))
+    s2 = s.map(lambda x: np.where(x == 0, 0, 1))
+    assert issubclass(s2.dtype.type, np.integer)
+
+
+def test_map_decimal(string_series):
+    result = string_series.map(lambda x: Decimal(str(x)))
+    assert result.dtype == np.object_
+    assert isinstance(result.iloc[0], Decimal)
+
+
+def test_map_na_exclusion():
+    s = Series([1.5, np.nan, 3, np.nan, 5])
+
+    result = s.map(lambda x: x * 2, na_action="ignore")
+    exp = s * 2
+    tm.assert_series_equal(result, exp)
+
+
+def test_map_dict_with_tuple_keys():
+    """
+    Due to new MultiIndex-ing behaviour in v0.14.0,
+    dicts with tuple keys passed to map were being
+    converted to a multi-index, preventing tuple values
+    from being mapped properly.
+    """
+    # GH 18496
+    df = DataFrame({"a": [(1,), (2,), (3, 4), (5, 6)]})
+    label_mappings = {(1,): "A", (2,): "B", (3, 4): "A", (5, 6): "B"}
+
+    df["labels"] = df["a"].map(label_mappings)
+    df["expected_labels"] = Series(["A", "B", "A", "B"], index=df.index)
+    # All labels should be filled now
+    tm.assert_series_equal(df["labels"], df["expected_labels"], check_names=False)
+
+
+def test_map_counter():
+    s = Series(["a", "b", "c"], index=[1, 2, 3])
+    counter = Counter()
+    counter["b"] = 5
+    counter["c"] += 1
+    result = s.map(counter)
+    expected = Series([0, 5, 1], index=[1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_defaultdict():
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    default_dict = defaultdict(lambda: "blank")
+    default_dict[1] = "stuff"
+    result = s.map(default_dict)
+    expected = Series(["stuff", "blank", "blank"], index=["a", "b", "c"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_dict_na_key():
+    # https://github.com/pandas-dev/pandas/issues/17648
+    # Checks that np.nan key is appropriately mapped
+    s = Series([1, 2, np.nan])
+    expected = Series(["a", "b", "c"])
+    result = s.map({1: "a", 2: "b", np.nan: "c"})
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("na_action", [None, "ignore"])
+def test_map_defaultdict_na_key(na_action):
+    # GH 48813
+    s = Series([1, 2, np.nan])
+    default_map = defaultdict(lambda: "missing", {1: "a", 2: "b", np.nan: "c"})
+    result = s.map(default_map, na_action=na_action)
+    expected = Series({0: "a", 1: "b", 2: "c" if na_action is None else np.nan})
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("na_action", [None, "ignore"])
+def test_map_defaultdict_missing_key(na_action):
+    # GH 48813
+    s = Series([1, 2, np.nan])
+    default_map = defaultdict(lambda: "missing", {1: "a", 2: "b", 3: "c"})
+    result = s.map(default_map, na_action=na_action)
+    expected = Series({0: "a", 1: "b", 2: "missing" if na_action is None else np.nan})
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("na_action", [None, "ignore"])
+def test_map_defaultdict_unmutated(na_action):
+    # GH 48813
+    s = Series([1, 2, np.nan])
+    default_map = defaultdict(lambda: "missing", {1: "a", 2: "b", np.nan: "c"})
+    expected_default_map = default_map.copy()
+    s.map(default_map, na_action=na_action)
+    assert default_map == expected_default_map
+
+
+@pytest.mark.parametrize("arg_func", [dict, Series])
+def test_map_dict_ignore_na(arg_func):
+    # GH#47527
+    mapping = arg_func({1: 10, np.nan: 42})
+    ser = Series([1, np.nan, 2])
+    result = ser.map(mapping, na_action="ignore")
+    expected = Series([10, np.nan, np.nan])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_defaultdict_ignore_na():
+    # GH#47527
+    mapping = defaultdict(int, {1: 10, np.nan: 42})
+    ser = Series([1, np.nan, 2])
+    result = ser.map(mapping)
+    expected = Series([10, 42, 0])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "na_action, expected",
+    [(None, Series([10.0, 42.0, np.nan])), ("ignore", Series([10, np.nan, np.nan]))],
+)
+def test_map_categorical_na_ignore(na_action, expected):
+    # GH#47527
+    values = pd.Categorical([1, np.nan, 2], categories=[10, 1, 2])
+    ser = Series(values)
+    result = ser.map({1: 10, np.nan: 42}, na_action=na_action)
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_dict_subclass_with_missing():
+    """
+    Test Series.map with a dictionary subclass that defines __missing__,
+    i.e. sets a default value (GH #15999).
+    """
+
+    class DictWithMissing(dict):
+        def __missing__(self, key):
+            return "missing"
+
+    s = Series([1, 2, 3])
+    dictionary = DictWithMissing({3: "three"})
+    result = s.map(dictionary)
+    expected = Series(["missing", "missing", "three"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_dict_subclass_without_missing():
+    class DictWithoutMissing(dict):
+        pass
+
+    s = Series([1, 2, 3])
+    dictionary = DictWithoutMissing({3: "three"})
+    result = s.map(dictionary)
+    expected = Series([np.nan, np.nan, "three"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_abc_mapping(non_dict_mapping_subclass):
+    # https://github.com/pandas-dev/pandas/issues/29733
+    # Check collections.abc.Mapping support as mapper for Series.map
+    s = Series([1, 2, 3])
+    not_a_dictionary = non_dict_mapping_subclass({3: "three"})
+    result = s.map(not_a_dictionary)
+    expected = Series([np.nan, np.nan, "three"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_abc_mapping_with_missing(non_dict_mapping_subclass):
+    # https://github.com/pandas-dev/pandas/issues/29733
+    # Check collections.abc.Mapping support as mapper for Series.map
+    class NonDictMappingWithMissing(non_dict_mapping_subclass):
+        def __missing__(self, key):
+            return "missing"
+
+    s = Series([1, 2, 3])
+    not_a_dictionary = NonDictMappingWithMissing({3: "three"})
+    result = s.map(not_a_dictionary)
+    # __missing__ is a dict concept, not a Mapping concept,
+    # so it should not change the result!
+    expected = Series([np.nan, np.nan, "three"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_box():
+    vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]
+    s = Series(vals)
+    assert s.dtype == "datetime64[ns]"
+    # boxed value must be Timestamp instance
+    res = s.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
+    exp = Series(["Timestamp_1_None", "Timestamp_2_None"])
+    tm.assert_series_equal(res, exp)
+
+    vals = [
+        pd.Timestamp("2011-01-01", tz="US/Eastern"),
+        pd.Timestamp("2011-01-02", tz="US/Eastern"),
+    ]
+    s = Series(vals)
+    assert s.dtype == "datetime64[ns, US/Eastern]"
+    res = s.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}")
+    exp = Series(["Timestamp_1_US/Eastern", "Timestamp_2_US/Eastern"])
+    tm.assert_series_equal(res, exp)
+
+    # timedelta
+    vals = [pd.Timedelta("1 days"), pd.Timedelta("2 days")]
+    s = Series(vals)
+    assert s.dtype == "timedelta64[ns]"
+    res = s.map(lambda x: f"{type(x).__name__}_{x.days}")
+    exp = Series(["Timedelta_1", "Timedelta_2"])
+    tm.assert_series_equal(res, exp)
+
+    # period
+    vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
+    s = Series(vals)
+    assert s.dtype == "Period[M]"
+    res = s.map(lambda x: f"{type(x).__name__}_{x.freqstr}")
+    exp = Series(["Period_M", "Period_M"])
+    tm.assert_series_equal(res, exp)
+
+
+@pytest.mark.parametrize("na_action", [None, "ignore"])
+def test_map_categorical(na_action):
+    values = pd.Categorical(list("ABBABCD"), categories=list("DCBA"), ordered=True)
+    s = Series(values, name="XX", index=list("abcdefg"))
+
+    result = s.map(lambda x: x.lower(), na_action=na_action)
+    exp_values = pd.Categorical(list("abbabcd"), categories=list("dcba"), ordered=True)
+    exp = Series(exp_values, name="XX", index=list("abcdefg"))
+    tm.assert_series_equal(result, exp)
+    tm.assert_categorical_equal(result.values, exp_values)
+
+    result = s.map(lambda x: "A", na_action=na_action)
+    exp = Series(["A"] * 7, name="XX", index=list("abcdefg"))
+    tm.assert_series_equal(result, exp)
+    assert result.dtype == object
+
+
+@pytest.mark.parametrize(
+    "na_action, expected",
+    (
+        [None, Series(["A", "B", "nan"], name="XX")],
+        [
+            "ignore",
+            Series(
+                ["A", "B", np.nan],
+                name="XX",
+                dtype=pd.CategoricalDtype(list("DCBA"), True),
+            ),
+        ],
+    ),
+)
+def test_map_categorical_na_action(na_action, expected):
+    dtype = pd.CategoricalDtype(list("DCBA"), ordered=True)
+    values = pd.Categorical(list("AB") + [np.nan], dtype=dtype)
+    s = Series(values, name="XX")
+    result = s.map(str, na_action=na_action)
+    tm.assert_series_equal(result, expected)
+
+
+def test_map_datetimetz():
+    values = pd.date_range("2011-01-01", "2011-01-02", freq="H").tz_localize(
+        "Asia/Tokyo"
+    )
+    s = Series(values, name="XX")
+
+    # keep tz
+    result = s.map(lambda x: x + pd.offsets.Day())
+    exp_values = pd.date_range("2011-01-02", "2011-01-03", freq="H").tz_localize(
+        "Asia/Tokyo"
+    )
+    exp = Series(exp_values, name="XX")
+    tm.assert_series_equal(result, exp)
+
+    result = s.map(lambda x: x.hour)
+    exp = Series(list(range(24)) + [0], name="XX", dtype=np.int64)
+    tm.assert_series_equal(result, exp)
+
+    # not vectorized
+    def f(x):
+        if not isinstance(x, pd.Timestamp):
+            raise ValueError
+        return str(x.tz)
+
+    result = s.map(f)
+    exp = Series(["Asia/Tokyo"] * 25, name="XX")
+    tm.assert_series_equal(result, exp)
+
+
+@pytest.mark.parametrize(
+    "vals,mapping,exp",
+    [
+        (list("abc"), {np.nan: "not NaN"}, [np.nan] * 3 + ["not NaN"]),
+        (list("abc"), {"a": "a letter"}, ["a letter"] + [np.nan] * 3),
+        (list(range(3)), {0: 42}, [42] + [np.nan] * 3),
+    ],
+)
+def test_map_missing_mixed(vals, mapping, exp):
+    # GH20495
+    s = Series(vals + [np.nan])
+    result = s.map(mapping)
+
+    tm.assert_series_equal(result, Series(exp))
+
+
+def test_map_scalar_on_date_time_index_aware_series():
+    # GH 25959
+    # Calling map on a localized time series should not cause an error
+    series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
+    result = Series(series.index).map(lambda x: 1)
+    tm.assert_series_equal(result, Series(np.ones(30), dtype="int64"))
+
+
+def test_map_float_to_string_precision():
+    # GH 13228
+    ser = Series(1 / 3)
+    result = ser.map(lambda val: str(val)).to_dict()
+    expected = {0: "0.3333333333333333"}
+    assert result == expected
+
+
+def test_map_to_timedelta():
+    list_of_valid_strings = ["00:00:01", "00:00:02"]
+    a = pd.to_timedelta(list_of_valid_strings)
+    b = Series(list_of_valid_strings).map(pd.to_timedelta)
+    tm.assert_series_equal(Series(a), b)
+
+    list_of_strings = ["00:00:01", np.nan, pd.NaT, pd.NaT]
+
+    a = pd.to_timedelta(list_of_strings)
+    ser = Series(list_of_strings)
+    b = ser.map(pd.to_timedelta)
+    tm.assert_series_equal(Series(a), b)
+
+
+def test_map_type():
+    # GH 46719
+    s = Series([3, "string", float], index=["a", "b", "c"])
+    result = s.map(type)
+    expected = Series([int, str, type], index=["a", "b", "c"])
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_matmul.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_matmul.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ca3ad3f7031e20b8d6cec36caadbcefef8c4196
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_matmul.py
@@ -0,0 +1,82 @@
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestMatmul:
+    def test_matmul(self):
+        # matmul test is for GH#10259
+        a = Series(
+            np.random.default_rng(2).standard_normal(4), index=["p", "q", "r", "s"]
+        )
+        b = DataFrame(
+            np.random.default_rng(2).standard_normal((3, 4)),
+            index=["1", "2", "3"],
+            columns=["p", "q", "r", "s"],
+        ).T
+
+        # Series @ DataFrame -> Series
+        result = operator.matmul(a, b)
+        expected = Series(np.dot(a.values, b.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        # DataFrame @ Series -> Series
+        result = operator.matmul(b.T, a)
+        expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        # Series @ Series -> scalar
+        result = operator.matmul(a, a)
+        expected = np.dot(a.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # vector (1D np.array) @ Series (__rmatmul__)
+        result = operator.matmul(a.values, a)
+        expected = np.dot(a.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # vector (1D list) @ Series (__rmatmul__)
+        result = operator.matmul(a.values.tolist(), a)
+        expected = np.dot(a.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # matrix (2D np.array) @ Series (__rmatmul__)
+        result = operator.matmul(b.T.values, a)
+        expected = np.dot(b.T.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # matrix (2D nested lists) @ Series (__rmatmul__)
+        result = operator.matmul(b.T.values.tolist(), a)
+        expected = np.dot(b.T.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # mixed dtype DataFrame @ Series
+        a["p"] = int(a.p)
+        result = operator.matmul(b.T, a)
+        expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        # different dtypes DataFrame @ Series
+        a = a.astype(int)
+        result = operator.matmul(b.T, a)
+        expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        msg = r"Dot product shape mismatch, \(4,\) vs \(3,\)"
+        # exception raised is of type Exception
+        with pytest.raises(Exception, match=msg):
+            a.dot(a.values[:3])
+        msg = "matrices are not aligned"
+        with pytest.raises(ValueError, match=msg):
+            a.dot(b.T)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_nlargest.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_nlargest.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8de1cd89e3974f2dff0d775f35655b8caa02a08
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_nlargest.py
@@ -0,0 +1,248 @@
+"""
+Note: for naming purposes, most tests are title with as e.g. "test_nlargest_foo"
+but are implicitly also testing nsmallest_foo.
+"""
+from itertools import product
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+main_dtypes = [
+    "datetime",
+    "datetimetz",
+    "timedelta",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "float32",
+    "float64",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+]
+
+
+@pytest.fixture
+def s_main_dtypes():
+    """
+    A DataFrame with many dtypes
+
+    * datetime
+    * datetimetz
+    * timedelta
+    * [u]int{8,16,32,64}
+    * float{32,64}
+
+    The columns are the name of the dtype.
+    """
+    df = pd.DataFrame(
+        {
+            "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
+            "datetimetz": pd.to_datetime(
+                ["2003", "2002", "2001", "2002", "2005"]
+            ).tz_localize("US/Eastern"),
+            "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
+        }
+    )
+
+    for dtype in [
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+    ]:
+        df[dtype] = Series([3, 2, 1, 2, 5], dtype=dtype)
+
+    return df
+
+
+@pytest.fixture(params=main_dtypes)
+def s_main_dtypes_split(request, s_main_dtypes):
+    """Each series in s_main_dtypes."""
+    return s_main_dtypes[request.param]
+
+
+def assert_check_nselect_boundary(vals, dtype, method):
+    # helper function for 'test_boundary_{dtype}' tests
+    ser = Series(vals, dtype=dtype)
+    result = getattr(ser, method)(3)
+    expected_idxr = [0, 1, 2] if method == "nsmallest" else [3, 2, 1]
+    expected = ser.loc[expected_idxr]
+    tm.assert_series_equal(result, expected)
+
+
+class TestSeriesNLargestNSmallest:
+    @pytest.mark.parametrize(
+        "r",
+        [
+            Series([3.0, 2, 1, 2, "5"], dtype="object"),
+            Series([3.0, 2, 1, 2, 5], dtype="object"),
+            # not supported on some archs
+            # Series([3., 2, 1, 2, 5], dtype='complex256'),
+            Series([3.0, 2, 1, 2, 5], dtype="complex128"),
+            Series(list("abcde")),
+            Series(list("abcde"), dtype="category"),
+        ],
+    )
+    def test_nlargest_error(self, r):
+        dt = r.dtype
+        msg = f"Cannot use method 'n(largest|smallest)' with dtype {dt}"
+        args = 2, len(r), 0, -1
+        methods = r.nlargest, r.nsmallest
+        for method, arg in product(methods, args):
+            with pytest.raises(TypeError, match=msg):
+                method(arg)
+
+    def test_nsmallest_nlargest(self, s_main_dtypes_split):
+        # float, int, datetime64 (use i8), timedelts64 (same),
+        # object that are numbers, object that are strings
+        ser = s_main_dtypes_split
+
+        tm.assert_series_equal(ser.nsmallest(2), ser.iloc[[2, 1]])
+        tm.assert_series_equal(ser.nsmallest(2, keep="last"), ser.iloc[[2, 3]])
+
+        empty = ser.iloc[0:0]
+        tm.assert_series_equal(ser.nsmallest(0), empty)
+        tm.assert_series_equal(ser.nsmallest(-1), empty)
+        tm.assert_series_equal(ser.nlargest(0), empty)
+        tm.assert_series_equal(ser.nlargest(-1), empty)
+
+        tm.assert_series_equal(ser.nsmallest(len(ser)), ser.sort_values())
+        tm.assert_series_equal(ser.nsmallest(len(ser) + 1), ser.sort_values())
+        tm.assert_series_equal(ser.nlargest(len(ser)), ser.iloc[[4, 0, 1, 3, 2]])
+        tm.assert_series_equal(ser.nlargest(len(ser) + 1), ser.iloc[[4, 0, 1, 3, 2]])
+
+    def test_nlargest_misc(self):
+        ser = Series([3.0, np.nan, 1, 2, 5])
+        result = ser.nlargest()
+        expected = ser.iloc[[4, 0, 3, 2, 1]]
+        tm.assert_series_equal(result, expected)
+        result = ser.nsmallest()
+        expected = ser.iloc[[2, 3, 0, 4, 1]]
+        tm.assert_series_equal(result, expected)
+
+        msg = 'keep must be either "first", "last"'
+        with pytest.raises(ValueError, match=msg):
+            ser.nsmallest(keep="invalid")
+        with pytest.raises(ValueError, match=msg):
+            ser.nlargest(keep="invalid")
+
+        # GH#15297
+        ser = Series([1] * 5, index=[1, 2, 3, 4, 5])
+        expected_first = Series([1] * 3, index=[1, 2, 3])
+        expected_last = Series([1] * 3, index=[5, 4, 3])
+
+        result = ser.nsmallest(3)
+        tm.assert_series_equal(result, expected_first)
+
+        result = ser.nsmallest(3, keep="last")
+        tm.assert_series_equal(result, expected_last)
+
+        result = ser.nlargest(3)
+        tm.assert_series_equal(result, expected_first)
+
+        result = ser.nlargest(3, keep="last")
+        tm.assert_series_equal(result, expected_last)
+
+    @pytest.mark.parametrize("n", range(1, 5))
+    def test_nlargest_n(self, n):
+        # GH 13412
+        ser = Series([1, 4, 3, 2], index=[0, 0, 1, 1])
+        result = ser.nlargest(n)
+        expected = ser.sort_values(ascending=False).head(n)
+        tm.assert_series_equal(result, expected)
+
+        result = ser.nsmallest(n)
+        expected = ser.sort_values().head(n)
+        tm.assert_series_equal(result, expected)
+
+    def test_nlargest_boundary_integer(self, nselect_method, any_int_numpy_dtype):
+        # GH#21426
+        dtype_info = np.iinfo(any_int_numpy_dtype)
+        min_val, max_val = dtype_info.min, dtype_info.max
+        vals = [min_val, min_val + 1, max_val - 1, max_val]
+        assert_check_nselect_boundary(vals, any_int_numpy_dtype, nselect_method)
+
+    def test_nlargest_boundary_float(self, nselect_method, float_numpy_dtype):
+        # GH#21426
+        dtype_info = np.finfo(float_numpy_dtype)
+        min_val, max_val = dtype_info.min, dtype_info.max
+        min_2nd, max_2nd = np.nextafter([min_val, max_val], 0, dtype=float_numpy_dtype)
+        vals = [min_val, min_2nd, max_2nd, max_val]
+        assert_check_nselect_boundary(vals, float_numpy_dtype, nselect_method)
+
+    @pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+    def test_nlargest_boundary_datetimelike(self, nselect_method, dtype):
+        # GH#21426
+        # use int64 bounds and +1 to min_val since true minimum is NaT
+        # (include min_val/NaT at end to maintain same expected_idxr)
+        dtype_info = np.iinfo("int64")
+        min_val, max_val = dtype_info.min, dtype_info.max
+        vals = [min_val + 1, min_val + 2, max_val - 1, max_val, min_val]
+        assert_check_nselect_boundary(vals, dtype, nselect_method)
+
+    def test_nlargest_duplicate_keep_all_ties(self):
+        # see GH#16818
+        ser = Series([10, 9, 8, 7, 7, 7, 7, 6])
+        result = ser.nlargest(4, keep="all")
+        expected = Series([10, 9, 8, 7, 7, 7, 7])
+        tm.assert_series_equal(result, expected)
+
+        result = ser.nsmallest(2, keep="all")
+        expected = Series([6, 7, 7, 7, 7], index=[7, 3, 4, 5, 6])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "data,expected", [([True, False], [True]), ([True, False, True, True], [True])]
+    )
+    def test_nlargest_boolean(self, data, expected):
+        # GH#26154 : ensure True > False
+        ser = Series(data)
+        result = ser.nlargest(1)
+        expected = Series(expected)
+        tm.assert_series_equal(result, expected)
+
+    def test_nlargest_nullable(self, any_numeric_ea_dtype):
+        # GH#42816
+        dtype = any_numeric_ea_dtype
+        if dtype.startswith("UInt"):
+            # Can't cast from negative float to uint on some platforms
+            arr = np.random.default_rng(2).integers(1, 10, 10)
+        else:
+            arr = np.random.default_rng(2).standard_normal(10)
+        arr = arr.astype(dtype.lower(), copy=False)
+
+        ser = Series(arr.copy(), dtype=dtype)
+        ser[1] = pd.NA
+        result = ser.nlargest(5)
+
+        expected = (
+            Series(np.delete(arr, 1), index=ser.index.delete(1))
+            .nlargest(5)
+            .astype(dtype)
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_nsmallest_nan_when_keep_is_all(self):
+        # GH#46589
+        s = Series([1, 2, 3, 3, 3, None])
+        result = s.nsmallest(3, keep="all")
+        expected = Series([1.0, 2.0, 3.0, 3.0, 3.0])
+        tm.assert_series_equal(result, expected)
+
+        s = Series([1, 2, None, None, None])
+        result = s.nsmallest(3, keep="all")
+        expected = Series([1, 2, None, None, None])
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_nunique.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_nunique.py
new file mode 100644
index 0000000000000000000000000000000000000000..826132eb28162603d03635add59c3ea3da569256
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_nunique.py
@@ -0,0 +1,24 @@
+import numpy as np
+
+from pandas import (
+    Categorical,
+    Series,
+)
+
+
+def test_nunique():
+    # basics.rst doc example
+    series = Series(np.random.default_rng(2).standard_normal(500))
+    series[20:500] = np.nan
+    series[10:20] = 5000
+    result = series.nunique()
+    assert result == 11
+
+
+def test_nunique_categorical():
+    # GH#18051
+    ser = Series(Categorical([]))
+    assert ser.nunique() == 0
+
+    ser = Series(Categorical([np.nan]))
+    assert ser.nunique() == 0
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_pct_change.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_pct_change.py
new file mode 100644
index 0000000000000000000000000000000000000000..9727ef3d5c27c2a4f695df5fffd30323766c93e5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_pct_change.py
@@ -0,0 +1,120 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestSeriesPctChange:
+    def test_pct_change(self, datetime_series):
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "Series.pct_change are deprecated"
+        )
+
+        rs = datetime_series.pct_change(fill_method=None)
+        tm.assert_series_equal(rs, datetime_series / datetime_series.shift(1) - 1)
+
+        rs = datetime_series.pct_change(2)
+        filled = datetime_series.ffill()
+        tm.assert_series_equal(rs, filled / filled.shift(2) - 1)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs = datetime_series.pct_change(fill_method="bfill", limit=1)
+        filled = datetime_series.bfill(limit=1)
+        tm.assert_series_equal(rs, filled / filled.shift(1) - 1)
+
+        rs = datetime_series.pct_change(freq="5D")
+        filled = datetime_series.ffill()
+        tm.assert_series_equal(
+            rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
+        )
+
+    def test_pct_change_with_duplicate_axis(self):
+        # GH#28664
+        common_idx = date_range("2019-11-14", periods=5, freq="D")
+        result = Series(range(5), common_idx).pct_change(freq="B")
+
+        # the reason that the expected should be like this is documented at PR 28681
+        expected = Series([np.nan, np.inf, np.nan, np.nan, 3.0], common_idx)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_pct_change_shift_over_nas(self):
+        s = Series([1.0, 1.5, np.nan, 2.5, 3.0])
+
+        msg = "The default fill_method='pad' in Series.pct_change is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            chg = s.pct_change()
+
+        expected = Series([np.nan, 0.5, 0.0, 2.5 / 1.5 - 1, 0.2])
+        tm.assert_series_equal(chg, expected)
+
+    @pytest.mark.parametrize(
+        "freq, periods, fill_method, limit",
+        [
+            ("5B", 5, None, None),
+            ("3B", 3, None, None),
+            ("3B", 3, "bfill", None),
+            ("7B", 7, "pad", 1),
+            ("7B", 7, "bfill", 3),
+            ("14B", 14, None, None),
+        ],
+    )
+    def test_pct_change_periods_freq(
+        self, freq, periods, fill_method, limit, datetime_series
+    ):
+        msg = (
+            "The 'fill_method' keyword being not None and the 'limit' keyword in "
+            "Series.pct_change are deprecated"
+        )
+
+        # GH#7292
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_freq = datetime_series.pct_change(
+                freq=freq, fill_method=fill_method, limit=limit
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_periods = datetime_series.pct_change(
+                periods, fill_method=fill_method, limit=limit
+            )
+        tm.assert_series_equal(rs_freq, rs_periods)
+
+        empty_ts = Series(index=datetime_series.index, dtype=object)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_freq = empty_ts.pct_change(
+                freq=freq, fill_method=fill_method, limit=limit
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            rs_periods = empty_ts.pct_change(
+                periods, fill_method=fill_method, limit=limit
+            )
+        tm.assert_series_equal(rs_freq, rs_periods)
+
+
+@pytest.mark.parametrize("fill_method", ["pad", "ffill", None])
+def test_pct_change_with_duplicated_indices(fill_method):
+    # GH30463
+    s = Series([np.nan, 1, 2, 3, 9, 18], index=["a", "b"] * 3)
+
+    warn = None if fill_method is None else FutureWarning
+    msg = (
+        "The 'fill_method' keyword being not None and the 'limit' keyword in "
+        "Series.pct_change are deprecated"
+    )
+    with tm.assert_produces_warning(warn, match=msg):
+        result = s.pct_change(fill_method=fill_method)
+
+    expected = Series([np.nan, np.nan, 1.0, 0.5, 2.0, 1.0], index=["a", "b"] * 3)
+    tm.assert_series_equal(result, expected)
+
+
+def test_pct_change_no_warning_na_beginning():
+    # GH#54981
+    ser = Series([None, None, 1, 2, 3])
+    result = ser.pct_change()
+    expected = Series([np.nan, np.nan, np.nan, 1, 0.5])
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_pop.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_pop.py
new file mode 100644
index 0000000000000000000000000000000000000000..7453f98ab3735e924dd7601622d23b4bafdd2176
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_pop.py
@@ -0,0 +1,13 @@
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_pop():
+    # GH#6600
+    ser = Series([0, 4, 0], index=["A", "B", "C"], name=4)
+
+    result = ser.pop("B")
+    assert result == 4
+
+    expected = Series([0, 0], index=["A", "C"], name=4)
+    tm.assert_series_equal(ser, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_quantile.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_quantile.py
new file mode 100644
index 0000000000000000000000000000000000000000..70ad6b3016a57460fc06b447d849e7a02cf96412
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_quantile.py
@@ -0,0 +1,243 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.common import is_integer
+
+import pandas as pd
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.indexes.datetimes import Timestamp
+
+
+class TestSeriesQuantile:
+    def test_quantile(self, datetime_series):
+        q = datetime_series.quantile(0.1)
+        assert q == np.percentile(datetime_series.dropna(), 10)
+
+        q = datetime_series.quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
+
+        # object dtype
+        q = Series(datetime_series, dtype=object).quantile(0.9)
+        assert q == np.percentile(datetime_series.dropna(), 90)
+
+        # datetime64[ns] dtype
+        dts = datetime_series.index.to_series()
+        q = dts.quantile(0.2)
+        assert q == Timestamp("2000-01-10 19:12:00")
+
+        # timedelta64[ns] dtype
+        tds = dts.diff()
+        q = tds.quantile(0.25)
+        assert q == pd.to_timedelta("24:00:00")
+
+        # GH7661
+        result = Series([np.timedelta64("NaT")]).sum()
+        assert result == pd.Timedelta(0)
+
+        msg = "percentiles should all be in the interval \\[0, 1\\]"
+        for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
+            with pytest.raises(ValueError, match=msg):
+                datetime_series.quantile(invalid)
+
+        s = Series(np.random.default_rng(2).standard_normal(100))
+        percentile_array = [-0.5, 0.25, 1.5]
+        with pytest.raises(ValueError, match=msg):
+            s.quantile(percentile_array)
+
+    def test_quantile_multi(self, datetime_series):
+        qs = [0.1, 0.9]
+        result = datetime_series.quantile(qs)
+        expected = Series(
+            [
+                np.percentile(datetime_series.dropna(), 10),
+                np.percentile(datetime_series.dropna(), 90),
+            ],
+            index=qs,
+            name=datetime_series.name,
+        )
+        tm.assert_series_equal(result, expected)
+
+        dts = datetime_series.index.to_series()
+        dts.name = "xxx"
+        result = dts.quantile((0.2, 0.2))
+        expected = Series(
+            [Timestamp("2000-01-10 19:12:00"), Timestamp("2000-01-10 19:12:00")],
+            index=[0.2, 0.2],
+            name="xxx",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = datetime_series.quantile([])
+        expected = Series(
+            [], name=datetime_series.name, index=Index([], dtype=float), dtype="float64"
+        )
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_interpolation(self, datetime_series):
+        # see gh-10174
+
+        # interpolation = linear (default case)
+        q = datetime_series.quantile(0.1, interpolation="linear")
+        assert q == np.percentile(datetime_series.dropna(), 10)
+        q1 = datetime_series.quantile(0.1)
+        assert q1 == np.percentile(datetime_series.dropna(), 10)
+
+        # test with and without interpolation keyword
+        assert q == q1
+
+    def test_quantile_interpolation_dtype(self):
+        # GH #10174
+
+        # interpolation = linear (default case)
+        q = Series([1, 3, 4]).quantile(0.5, interpolation="lower")
+        assert q == np.percentile(np.array([1, 3, 4]), 50)
+        assert is_integer(q)
+
+        q = Series([1, 3, 4]).quantile(0.5, interpolation="higher")
+        assert q == np.percentile(np.array([1, 3, 4]), 50)
+        assert is_integer(q)
+
+    def test_quantile_nan(self):
+        # GH 13098
+        s = Series([1, 2, 3, 4, np.nan])
+        result = s.quantile(0.5)
+        expected = 2.5
+        assert result == expected
+
+        # all nan/empty
+        s1 = Series([], dtype=object)
+        cases = [s1, Series([np.nan, np.nan])]
+
+        for s in cases:
+            res = s.quantile(0.5)
+            assert np.isnan(res)
+
+            res = s.quantile([0.5])
+            tm.assert_series_equal(res, Series([np.nan], index=[0.5]))
+
+            res = s.quantile([0.2, 0.3])
+            tm.assert_series_equal(res, Series([np.nan, np.nan], index=[0.2, 0.3]))
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            [
+                Timestamp("2011-01-01"),
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-03"),
+            ],
+            [
+                Timestamp("2011-01-01", tz="US/Eastern"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                Timestamp("2011-01-03", tz="US/Eastern"),
+            ],
+            [pd.Timedelta("1 days"), pd.Timedelta("2 days"), pd.Timedelta("3 days")],
+            # NaT
+            [
+                Timestamp("2011-01-01"),
+                Timestamp("2011-01-02"),
+                Timestamp("2011-01-03"),
+                pd.NaT,
+            ],
+            [
+                Timestamp("2011-01-01", tz="US/Eastern"),
+                Timestamp("2011-01-02", tz="US/Eastern"),
+                Timestamp("2011-01-03", tz="US/Eastern"),
+                pd.NaT,
+            ],
+            [
+                pd.Timedelta("1 days"),
+                pd.Timedelta("2 days"),
+                pd.Timedelta("3 days"),
+                pd.NaT,
+            ],
+        ],
+    )
+    def test_quantile_box(self, case):
+        s = Series(case, name="XXX")
+        res = s.quantile(0.5)
+        assert res == case[1]
+
+        res = s.quantile([0.5])
+        exp = Series([case[1]], index=[0.5], name="XXX")
+        tm.assert_series_equal(res, exp)
+
+    def test_datetime_timedelta_quantiles(self):
+        # covers #9694
+        assert pd.isna(Series([], dtype="M8[ns]").quantile(0.5))
+        assert pd.isna(Series([], dtype="m8[ns]").quantile(0.5))
+
+    def test_quantile_nat(self):
+        res = Series([pd.NaT, pd.NaT]).quantile(0.5)
+        assert res is pd.NaT
+
+        res = Series([pd.NaT, pd.NaT]).quantile([0.5])
+        tm.assert_series_equal(res, Series([pd.NaT], index=[0.5]))
+
+    @pytest.mark.parametrize(
+        "values, dtype",
+        [([0, 0, 0, 1, 2, 3], "Sparse[int]"), ([0.0, None, 1.0, 2.0], "Sparse[float]")],
+    )
+    def test_quantile_sparse(self, values, dtype):
+        ser = Series(values, dtype=dtype)
+        result = ser.quantile([0.5])
+        expected = Series(np.asarray(ser)).quantile([0.5]).astype("Sparse[float]")
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_empty(self):
+        # floats
+        s = Series([], dtype="float64")
+
+        res = s.quantile(0.5)
+        assert np.isnan(res)
+
+        res = s.quantile([0.5])
+        exp = Series([np.nan], index=[0.5])
+        tm.assert_series_equal(res, exp)
+
+        # int
+        s = Series([], dtype="int64")
+
+        res = s.quantile(0.5)
+        assert np.isnan(res)
+
+        res = s.quantile([0.5])
+        exp = Series([np.nan], index=[0.5])
+        tm.assert_series_equal(res, exp)
+
+        # datetime
+        s = Series([], dtype="datetime64[ns]")
+
+        res = s.quantile(0.5)
+        assert res is pd.NaT
+
+        res = s.quantile([0.5])
+        exp = Series([pd.NaT], index=[0.5])
+        tm.assert_series_equal(res, exp)
+
+    @pytest.mark.parametrize("dtype", [int, float, "Int64"])
+    def test_quantile_dtypes(self, dtype):
+        result = Series([1, 2, 3], dtype=dtype).quantile(np.arange(0, 1, 0.25))
+        expected = Series(np.arange(1, 3, 0.5), index=np.arange(0, 1, 0.25))
+        if dtype == "Int64":
+            expected = expected.astype("Float64")
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_all_na(self, any_int_ea_dtype):
+        # GH#50681
+        ser = Series([pd.NA, pd.NA], dtype=any_int_ea_dtype)
+        with tm.assert_produces_warning(None):
+            result = ser.quantile([0.1, 0.5])
+        expected = Series([pd.NA, pd.NA], dtype=any_int_ea_dtype, index=[0.1, 0.5])
+        tm.assert_series_equal(result, expected)
+
+    def test_quantile_dtype_size(self, any_int_ea_dtype):
+        # GH#50681
+        ser = Series([pd.NA, pd.NA, 1], dtype=any_int_ea_dtype)
+        result = ser.quantile([0.1, 0.5])
+        expected = Series([1, 1], dtype=any_int_ea_dtype, index=[0.1, 0.5])
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rank.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rank.py
new file mode 100644
index 0000000000000000000000000000000000000000..24cf97c05c0a810bac00a8843b21d0ee88a1c00d
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rank.py
@@ -0,0 +1,519 @@
+from itertools import chain
+import operator
+
+import numpy as np
+import pytest
+
+from pandas._libs.algos import (
+    Infinity,
+    NegInfinity,
+)
+import pandas.util._test_decorators as td
+
+from pandas import (
+    NA,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.types import CategoricalDtype
+
+
+@pytest.fixture
+def ser():
+    return Series([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])
+
+
+@pytest.fixture(
+    params=[
+        ["average", np.array([1.5, 5.5, 7.0, 3.5, np.nan, 3.5, 1.5, 8.0, np.nan, 5.5])],
+        ["min", np.array([1, 5, 7, 3, np.nan, 3, 1, 8, np.nan, 5])],
+        ["max", np.array([2, 6, 7, 4, np.nan, 4, 2, 8, np.nan, 6])],
+        ["first", np.array([1, 5, 7, 3, np.nan, 4, 2, 8, np.nan, 6])],
+        ["dense", np.array([1, 3, 4, 2, np.nan, 2, 1, 5, np.nan, 3])],
+    ]
+)
+def results(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        "object",
+        "float64",
+        "int64",
+        "Float64",
+        "Int64",
+        pytest.param("float64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+        pytest.param("int64[pyarrow]", marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def dtype(request):
+    return request.param
+
+
+class TestSeriesRank:
+    def test_rank(self, datetime_series):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        datetime_series[::2] = np.nan
+        datetime_series[:10:3] = 4.0
+
+        ranks = datetime_series.rank()
+        oranks = datetime_series.astype("O").rank()
+
+        tm.assert_series_equal(ranks, oranks)
+
+        mask = np.isnan(datetime_series)
+        filled = datetime_series.fillna(np.inf)
+
+        # rankdata returns a ndarray
+        exp = Series(sp_stats.rankdata(filled), index=filled.index, name="ts")
+        exp[mask] = np.nan
+
+        tm.assert_series_equal(ranks, exp)
+
+        iseries = Series(np.arange(5).repeat(2))
+
+        iranks = iseries.rank()
+        exp = iseries.astype(float).rank()
+        tm.assert_series_equal(iranks, exp)
+        iseries = Series(np.arange(5)) + 1.0
+        exp = iseries / 5.0
+        iranks = iseries.rank(pct=True)
+
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series(np.repeat(1, 100))
+        exp = Series(np.repeat(0.505, 100))
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        # Explicit cast to float to avoid implicit cast when setting nan
+        iseries = iseries.astype("float")
+        iseries[1] = np.nan
+        exp = Series(np.repeat(50.0 / 99.0, 100))
+        exp[1] = np.nan
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series(np.arange(5)) + 1.0
+        iseries[4] = np.nan
+        exp = iseries / 4.0
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series(np.repeat(np.nan, 100))
+        exp = iseries.copy()
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        # Explicit cast to float to avoid implicit cast when setting nan
+        iseries = Series(np.arange(5), dtype="float") + 1
+        iseries[4] = np.nan
+        exp = iseries / 4.0
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        rng = date_range("1/1/1990", periods=5)
+        # Explicit cast to float to avoid implicit cast when setting nan
+        iseries = Series(np.arange(5), rng, dtype="float") + 1
+        iseries.iloc[4] = np.nan
+        exp = iseries / 4.0
+        iranks = iseries.rank(pct=True)
+        tm.assert_series_equal(iranks, exp)
+
+        iseries = Series([1e-50, 1e-100, 1e-20, 1e-2, 1e-20 + 1e-30, 1e-1])
+        exp = Series([2, 1, 3, 5, 4, 6.0])
+        iranks = iseries.rank()
+        tm.assert_series_equal(iranks, exp)
+
+        # GH 5968
+        iseries = Series(["3 day", "1 day 10m", "-2 day", NaT], dtype="m8[ns]")
+        exp = Series([3, 2, 1, np.nan])
+        iranks = iseries.rank()
+        tm.assert_series_equal(iranks, exp)
+
+        values = np.array(
+            [-50, -1, -1e-20, -1e-25, -1e-50, 0, 1e-40, 1e-20, 1e-10, 2, 40],
+            dtype="float64",
+        )
+        random_order = np.random.default_rng(2).permutation(len(values))
+        iseries = Series(values[random_order])
+        exp = Series(random_order + 1.0, dtype="float64")
+        iranks = iseries.rank()
+        tm.assert_series_equal(iranks, exp)
+
+    def test_rank_categorical(self):
+        # GH issue #15420 rank incorrectly orders ordered categories
+
+        # Test ascending/descending ranking for ordered categoricals
+        exp = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        exp_desc = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
+        ordered = Series(
+            ["first", "second", "third", "fourth", "fifth", "sixth"]
+        ).astype(
+            CategoricalDtype(
+                categories=["first", "second", "third", "fourth", "fifth", "sixth"],
+                ordered=True,
+            )
+        )
+        tm.assert_series_equal(ordered.rank(), exp)
+        tm.assert_series_equal(ordered.rank(ascending=False), exp_desc)
+
+        # Unordered categoricals should be ranked as objects
+        unordered = Series(
+            ["first", "second", "third", "fourth", "fifth", "sixth"]
+        ).astype(
+            CategoricalDtype(
+                categories=["first", "second", "third", "fourth", "fifth", "sixth"],
+                ordered=False,
+            )
+        )
+        exp_unordered = Series([2.0, 4.0, 6.0, 3.0, 1.0, 5.0])
+        res = unordered.rank()
+        tm.assert_series_equal(res, exp_unordered)
+
+        unordered1 = Series([1, 2, 3, 4, 5, 6]).astype(
+            CategoricalDtype([1, 2, 3, 4, 5, 6], False)
+        )
+        exp_unordered1 = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        res1 = unordered1.rank()
+        tm.assert_series_equal(res1, exp_unordered1)
+
+        # Test na_option for rank data
+        na_ser = Series(
+            ["first", "second", "third", "fourth", "fifth", "sixth", np.nan]
+        ).astype(
+            CategoricalDtype(
+                ["first", "second", "third", "fourth", "fifth", "sixth", "seventh"],
+                True,
+            )
+        )
+
+        exp_top = Series([2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 1.0])
+        exp_bot = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+        exp_keep = Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, np.nan])
+
+        tm.assert_series_equal(na_ser.rank(na_option="top"), exp_top)
+        tm.assert_series_equal(na_ser.rank(na_option="bottom"), exp_bot)
+        tm.assert_series_equal(na_ser.rank(na_option="keep"), exp_keep)
+
+        # Test na_option for rank data with ascending False
+        exp_top = Series([7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0])
+        exp_bot = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 7.0])
+        exp_keep = Series([6.0, 5.0, 4.0, 3.0, 2.0, 1.0, np.nan])
+
+        tm.assert_series_equal(na_ser.rank(na_option="top", ascending=False), exp_top)
+        tm.assert_series_equal(
+            na_ser.rank(na_option="bottom", ascending=False), exp_bot
+        )
+        tm.assert_series_equal(na_ser.rank(na_option="keep", ascending=False), exp_keep)
+
+        # Test invalid values for na_option
+        msg = "na_option must be one of 'keep', 'top', or 'bottom'"
+
+        with pytest.raises(ValueError, match=msg):
+            na_ser.rank(na_option="bad", ascending=False)
+
+        # invalid type
+        with pytest.raises(ValueError, match=msg):
+            na_ser.rank(na_option=True, ascending=False)
+
+        # Test with pct=True
+        na_ser = Series(["first", "second", "third", "fourth", np.nan]).astype(
+            CategoricalDtype(["first", "second", "third", "fourth"], True)
+        )
+        exp_top = Series([0.4, 0.6, 0.8, 1.0, 0.2])
+        exp_bot = Series([0.2, 0.4, 0.6, 0.8, 1.0])
+        exp_keep = Series([0.25, 0.5, 0.75, 1.0, np.nan])
+
+        tm.assert_series_equal(na_ser.rank(na_option="top", pct=True), exp_top)
+        tm.assert_series_equal(na_ser.rank(na_option="bottom", pct=True), exp_bot)
+        tm.assert_series_equal(na_ser.rank(na_option="keep", pct=True), exp_keep)
+
+    def test_rank_signature(self):
+        s = Series([0, 1])
+        s.rank(method="average")
+        msg = "No axis named average for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            s.rank("average")
+
+    @pytest.mark.parametrize("dtype", [None, object])
+    def test_rank_tie_methods(self, ser, results, dtype):
+        method, exp = results
+        ser = ser if dtype is None else ser.astype(dtype)
+        result = ser.rank(method=method)
+        tm.assert_series_equal(result, Series(exp))
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    @pytest.mark.parametrize("method", ["average", "min", "max", "first", "dense"])
+    @pytest.mark.parametrize("na_option", ["top", "bottom", "keep"])
+    @pytest.mark.parametrize(
+        "dtype, na_value, pos_inf, neg_inf",
+        [
+            ("object", None, Infinity(), NegInfinity()),
+            ("float64", np.nan, np.inf, -np.inf),
+            ("Float64", NA, np.inf, -np.inf),
+            pytest.param(
+                "float64[pyarrow]",
+                NA,
+                np.inf,
+                -np.inf,
+                marks=td.skip_if_no("pyarrow"),
+            ),
+        ],
+    )
+    def test_rank_tie_methods_on_infs_nans(
+        self, method, na_option, ascending, dtype, na_value, pos_inf, neg_inf
+    ):
+        pytest.importorskip("scipy")
+        if dtype == "float64[pyarrow]":
+            if method == "average":
+                exp_dtype = "float64[pyarrow]"
+            else:
+                exp_dtype = "uint64[pyarrow]"
+        else:
+            exp_dtype = "float64"
+
+        chunk = 3
+        in_arr = [neg_inf] * chunk + [na_value] * chunk + [pos_inf] * chunk
+        iseries = Series(in_arr, dtype=dtype)
+        exp_ranks = {
+            "average": ([2, 2, 2], [5, 5, 5], [8, 8, 8]),
+            "min": ([1, 1, 1], [4, 4, 4], [7, 7, 7]),
+            "max": ([3, 3, 3], [6, 6, 6], [9, 9, 9]),
+            "first": ([1, 2, 3], [4, 5, 6], [7, 8, 9]),
+            "dense": ([1, 1, 1], [2, 2, 2], [3, 3, 3]),
+        }
+        ranks = exp_ranks[method]
+        if na_option == "top":
+            order = [ranks[1], ranks[0], ranks[2]]
+        elif na_option == "bottom":
+            order = [ranks[0], ranks[2], ranks[1]]
+        else:
+            order = [ranks[0], [np.nan] * chunk, ranks[1]]
+        expected = order if ascending else order[::-1]
+        expected = list(chain.from_iterable(expected))
+        result = iseries.rank(method=method, na_option=na_option, ascending=ascending)
+        tm.assert_series_equal(result, Series(expected, dtype=exp_dtype))
+
+    def test_rank_desc_mix_nans_infs(self):
+        # GH 19538
+        # check descending ranking when mix nans and infs
+        iseries = Series([1, np.nan, np.inf, -np.inf, 25])
+        result = iseries.rank(ascending=False)
+        exp = Series([3, np.nan, 1, 4, 2], dtype="float64")
+        tm.assert_series_equal(result, exp)
+
+    @pytest.mark.parametrize("method", ["average", "min", "max", "first", "dense"])
+    @pytest.mark.parametrize(
+        "op, value",
+        [
+            [operator.add, 0],
+            [operator.add, 1e6],
+            [operator.mul, 1e-6],
+        ],
+    )
+    def test_rank_methods_series(self, method, op, value):
+        sp_stats = pytest.importorskip("scipy.stats")
+
+        xs = np.random.default_rng(2).standard_normal(9)
+        xs = np.concatenate([xs[i:] for i in range(0, 9, 2)])  # add duplicates
+        np.random.default_rng(2).shuffle(xs)
+
+        index = [chr(ord("a") + i) for i in range(len(xs))]
+        vals = op(xs, value)
+        ts = Series(vals, index=index)
+        result = ts.rank(method=method)
+        sprank = sp_stats.rankdata(vals, method if method != "first" else "ordinal")
+        expected = Series(sprank, index=index).astype("float64")
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, exp",
+        [
+            ([1], [1]),
+            ([2], [1]),
+            ([0], [1]),
+            ([2, 2], [1, 1]),
+            ([1, 2, 3], [1, 2, 3]),
+            ([4, 2, 1], [3, 2, 1]),
+            ([1, 1, 5, 5, 3], [1, 1, 3, 3, 2]),
+            ([-5, -4, -3, -2, -1], [1, 2, 3, 4, 5]),
+        ],
+    )
+    def test_rank_dense_method(self, dtype, ser, exp):
+        s = Series(ser).astype(dtype)
+        result = s.rank(method="dense")
+        expected = Series(exp).astype(result.dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_rank_descending(self, ser, results, dtype):
+        method, _ = results
+        if "i" in dtype:
+            s = ser.dropna()
+        else:
+            s = ser.astype(dtype)
+
+        res = s.rank(ascending=False)
+        expected = (s.max() - s).rank()
+        tm.assert_series_equal(res, expected)
+
+        expected = (s.max() - s).rank(method=method)
+        res2 = s.rank(method=method, ascending=False)
+        tm.assert_series_equal(res2, expected)
+
+    def test_rank_int(self, ser, results):
+        method, exp = results
+        s = ser.dropna().astype("i8")
+
+        result = s.rank(method=method)
+        expected = Series(exp).dropna()
+        expected.index = result.index
+        tm.assert_series_equal(result, expected)
+
+    def test_rank_object_bug(self):
+        # GH 13445
+
+        # smoke tests
+        Series([np.nan] * 32).astype(object).rank(ascending=True)
+        Series([np.nan] * 32).astype(object).rank(ascending=False)
+
+    def test_rank_modify_inplace(self):
+        # GH 18521
+        # Check rank does not mutate series
+        s = Series([Timestamp("2017-01-05 10:20:27.569000"), NaT])
+        expected = s.copy()
+
+        s.rank()
+        result = s
+        tm.assert_series_equal(result, expected)
+
+    def test_rank_ea_small_values(self):
+        # GH#52471
+        ser = Series(
+            [5.4954145e29, -9.791984e-21, 9.3715776e-26, NA, 1.8790257e-28],
+            dtype="Float64",
+        )
+        result = ser.rank(method="min")
+        expected = Series([4, 1, 3, np.nan, 2])
+        tm.assert_series_equal(result, expected)
+
+
+# GH15630, pct should be on 100% basis when method='dense'
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0, 1.0]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 2, 2.0 / 2, 2.0 / 2]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.0 / 3, 1.0 / 3, 3.0 / 3, 3.0 / 3, 2.0 / 3]),
+        ([1, 1, 3, 3, 5, 5], [1.0 / 3, 1.0 / 3, 2.0 / 3, 2.0 / 3, 3.0 / 3, 3.0 / 3]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_dense_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="dense", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0 / 2, 1.0 / 2]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 2.0 / 3, 2.0 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.0 / 5, 1.0 / 5, 4.0 / 5, 4.0 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [1.0 / 6, 1.0 / 6, 3.0 / 6, 3.0 / 6, 5.0 / 6, 5.0 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_min_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="min", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0, 1.0]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 3.0 / 3, 3.0 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [2.0 / 5, 2.0 / 5, 5.0 / 5, 5.0 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [2.0 / 6, 2.0 / 6, 4.0 / 6, 4.0 / 6, 6.0 / 6, 6.0 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_max_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="max", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.5 / 2, 1.5 / 2]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 2.5 / 3, 2.5 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.5 / 5, 1.5 / 5, 4.5 / 5, 4.5 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [1.5 / 6, 1.5 / 6, 3.5 / 6, 3.5 / 6, 5.5 / 6, 5.5 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_average_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="average", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser, exp",
+    [
+        ([1], [1.0]),
+        ([1, 2], [1.0 / 2, 2.0 / 2]),
+        ([2, 2], [1.0 / 2, 2.0 / 2.0]),
+        ([1, 2, 3], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([1, 2, 2], [1.0 / 3, 2.0 / 3, 3.0 / 3]),
+        ([4, 2, 1], [3.0 / 3, 2.0 / 3, 1.0 / 3]),
+        ([1, 1, 5, 5, 3], [1.0 / 5, 2.0 / 5, 4.0 / 5, 5.0 / 5, 3.0 / 5]),
+        ([1, 1, 3, 3, 5, 5], [1.0 / 6, 2.0 / 6, 3.0 / 6, 4.0 / 6, 5.0 / 6, 6.0 / 6]),
+        ([-5, -4, -3, -2, -1], [1.0 / 5, 2.0 / 5, 3.0 / 5, 4.0 / 5, 5.0 / 5]),
+    ],
+)
+def test_rank_first_pct(dtype, ser, exp):
+    s = Series(ser).astype(dtype)
+    result = s.rank(method="first", pct=True)
+    expected = Series(exp).astype(result.dtype)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.single_cpu
+def test_pct_max_many_rows():
+    # GH 18271
+    s = Series(np.arange(2**24 + 1))
+    result = s.rank(pct=True).max()
+    assert result == 1
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reindex.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..c29c3297eb63b5f36dd2c661d06e0b2c5fe655d8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reindex.py
@@ -0,0 +1,444 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    NA,
+    Categorical,
+    Float64Dtype,
+    Index,
+    MultiIndex,
+    NaT,
+    Period,
+    PeriodIndex,
+    RangeIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    isna,
+)
+import pandas._testing as tm
+
+
+def test_reindex(datetime_series, string_series):
+    identity = string_series.reindex(string_series.index)
+
+    # __array_interface__ is not defined for older numpies
+    # and on some pythons
+    try:
+        assert np.may_share_memory(string_series.index, identity.index)
+    except AttributeError:
+        pass
+
+    assert identity.index.is_(string_series.index)
+    assert identity.index.identical(string_series.index)
+
+    subIndex = string_series.index[10:20]
+    subSeries = string_series.reindex(subIndex)
+
+    for idx, val in subSeries.items():
+        assert val == string_series[idx]
+
+    subIndex2 = datetime_series.index[10:20]
+    subTS = datetime_series.reindex(subIndex2)
+
+    for idx, val in subTS.items():
+        assert val == datetime_series[idx]
+    stuffSeries = datetime_series.reindex(subIndex)
+
+    assert np.isnan(stuffSeries).all()
+
+    # This is extremely important for the Cython code to not screw up
+    nonContigIndex = datetime_series.index[::2]
+    subNonContig = datetime_series.reindex(nonContigIndex)
+    for idx, val in subNonContig.items():
+        assert val == datetime_series[idx]
+
+    # return a copy the same index here
+    result = datetime_series.reindex()
+    assert result is not datetime_series
+
+
+def test_reindex_nan():
+    ts = Series([2, 3, 5, 7], index=[1, 4, np.nan, 8])
+
+    i, j = [np.nan, 1, np.nan, 8, 4, np.nan], [2, 0, 2, 3, 1, 2]
+    tm.assert_series_equal(ts.reindex(i), ts.iloc[j])
+
+    ts.index = ts.index.astype("object")
+
+    # reindex coerces index.dtype to float, loc/iloc doesn't
+    tm.assert_series_equal(ts.reindex(i), ts.iloc[j], check_index_type=False)
+
+
+def test_reindex_series_add_nat():
+    rng = date_range("1/1/2000 00:00:00", periods=10, freq="10s")
+    series = Series(rng)
+
+    result = series.reindex(range(15))
+    assert np.issubdtype(result.dtype, np.dtype("M8[ns]"))
+
+    mask = result.isna()
+    assert mask[-5:].all()
+    assert not mask[:-5].any()
+
+
+def test_reindex_with_datetimes():
+    rng = date_range("1/1/2000", periods=20)
+    ts = Series(np.random.default_rng(2).standard_normal(20), index=rng)
+
+    result = ts.reindex(list(ts.index[5:10]))
+    expected = ts[5:10]
+    expected.index = expected.index._with_freq(None)
+    tm.assert_series_equal(result, expected)
+
+    result = ts[list(ts.index[5:10])]
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_corner(datetime_series):
+    # (don't forget to fix this) I think it's fixed
+    empty = Series(index=[])
+    empty.reindex(datetime_series.index, method="pad")  # it works
+
+    # corner case: pad empty series
+    reindexed = empty.reindex(datetime_series.index, method="pad")
+
+    # pass non-Index
+    reindexed = datetime_series.reindex(list(datetime_series.index))
+    datetime_series.index = datetime_series.index._with_freq(None)
+    tm.assert_series_equal(datetime_series, reindexed)
+
+    # bad fill method
+    ts = datetime_series[::2]
+    msg = (
+        r"Invalid fill method\. Expecting pad \(ffill\), backfill "
+        r"\(bfill\) or nearest\. Got foo"
+    )
+    with pytest.raises(ValueError, match=msg):
+        ts.reindex(datetime_series.index, method="foo")
+
+
+def test_reindex_pad():
+    s = Series(np.arange(10), dtype="int64")
+    s2 = s[::2]
+
+    reindexed = s2.reindex(s.index, method="pad")
+    reindexed2 = s2.reindex(s.index, method="ffill")
+    tm.assert_series_equal(reindexed, reindexed2)
+
+    expected = Series([0, 0, 2, 2, 4, 4, 6, 6, 8, 8])
+    tm.assert_series_equal(reindexed, expected)
+
+
+def test_reindex_pad2():
+    # GH4604
+    s = Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
+    new_index = ["a", "g", "c", "f"]
+    expected = Series([1, 1, 3, 3], index=new_index)
+
+    # this changes dtype because the ffill happens after
+    result = s.reindex(new_index).ffill()
+    tm.assert_series_equal(result, expected.astype("float64"))
+
+    msg = "The 'downcast' keyword in ffill is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = s.reindex(new_index).ffill(downcast="infer")
+    tm.assert_series_equal(result, expected)
+
+    expected = Series([1, 5, 3, 5], index=new_index)
+    result = s.reindex(new_index, method="ffill")
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_inference():
+    # inference of new dtype
+    s = Series([True, False, False, True], index=list("abcd"))
+    new_index = "agc"
+    result = s.reindex(list(new_index)).ffill()
+    expected = Series([True, True, False], index=list(new_index))
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_downcasting():
+    # GH4618 shifted series downcasting
+    s = Series(False, index=range(0, 5))
+    result = s.shift(1).bfill()
+    expected = Series(False, index=range(0, 5))
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_nearest():
+    s = Series(np.arange(10, dtype="int64"))
+    target = [0.1, 0.9, 1.5, 2.0]
+    result = s.reindex(target, method="nearest")
+    expected = Series(np.around(target).astype("int64"), target)
+    tm.assert_series_equal(expected, result)
+
+    result = s.reindex(target, method="nearest", tolerance=0.2)
+    expected = Series([0, 1, np.nan, 2], target)
+    tm.assert_series_equal(expected, result)
+
+    result = s.reindex(target, method="nearest", tolerance=[0.3, 0.01, 0.4, 3])
+    expected = Series([0, np.nan, np.nan, 2], target)
+    tm.assert_series_equal(expected, result)
+
+
+def test_reindex_int(datetime_series):
+    ts = datetime_series[::2]
+    int_ts = Series(np.zeros(len(ts), dtype=int), index=ts.index)
+
+    # this should work fine
+    reindexed_int = int_ts.reindex(datetime_series.index)
+
+    # if NaNs introduced
+    assert reindexed_int.dtype == np.float64
+
+    # NO NaNs introduced
+    reindexed_int = int_ts.reindex(int_ts.index[::2])
+    assert reindexed_int.dtype == np.dtype(int)
+
+
+def test_reindex_bool(datetime_series):
+    # A series other than float, int, string, or object
+    ts = datetime_series[::2]
+    bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
+
+    # this should work fine
+    reindexed_bool = bool_ts.reindex(datetime_series.index)
+
+    # if NaNs introduced
+    assert reindexed_bool.dtype == np.object_
+
+    # NO NaNs introduced
+    reindexed_bool = bool_ts.reindex(bool_ts.index[::2])
+    assert reindexed_bool.dtype == np.bool_
+
+
+def test_reindex_bool_pad(datetime_series):
+    # fail
+    ts = datetime_series[5:]
+    bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
+    filled_bool = bool_ts.reindex(datetime_series.index, method="pad")
+    assert isna(filled_bool[:5]).all()
+
+
+def test_reindex_categorical():
+    index = date_range("20000101", periods=3)
+
+    # reindexing to an invalid Categorical
+    s = Series(["a", "b", "c"], dtype="category")
+    result = s.reindex(index)
+    expected = Series(
+        Categorical(values=[np.nan, np.nan, np.nan], categories=["a", "b", "c"])
+    )
+    expected.index = index
+    tm.assert_series_equal(result, expected)
+
+    # partial reindexing
+    expected = Series(Categorical(values=["b", "c"], categories=["a", "b", "c"]))
+    expected.index = [1, 2]
+    result = s.reindex([1, 2])
+    tm.assert_series_equal(result, expected)
+
+    expected = Series(Categorical(values=["c", np.nan], categories=["a", "b", "c"]))
+    expected.index = [2, 3]
+    result = s.reindex([2, 3])
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_astype_order_consistency():
+    # GH#17444
+    ser = Series([1, 2, 3], index=[2, 0, 1])
+    new_index = [0, 1, 2]
+    temp_dtype = "category"
+    new_dtype = str
+    result = ser.reindex(new_index).astype(temp_dtype).astype(new_dtype)
+    expected = ser.astype(temp_dtype).reindex(new_index).astype(new_dtype)
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_fill_value():
+    # -----------------------------------------------------------
+    # floats
+    floats = Series([1.0, 2.0, 3.0])
+    result = floats.reindex([1, 2, 3])
+    expected = Series([2.0, 3.0, np.nan], index=[1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+    result = floats.reindex([1, 2, 3], fill_value=0)
+    expected = Series([2.0, 3.0, 0], index=[1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+    # -----------------------------------------------------------
+    # ints
+    ints = Series([1, 2, 3])
+
+    result = ints.reindex([1, 2, 3])
+    expected = Series([2.0, 3.0, np.nan], index=[1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+    # don't upcast
+    result = ints.reindex([1, 2, 3], fill_value=0)
+    expected = Series([2, 3, 0], index=[1, 2, 3])
+    assert issubclass(result.dtype.type, np.integer)
+    tm.assert_series_equal(result, expected)
+
+    # -----------------------------------------------------------
+    # objects
+    objects = Series([1, 2, 3], dtype=object)
+
+    result = objects.reindex([1, 2, 3])
+    expected = Series([2, 3, np.nan], index=[1, 2, 3], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+    result = objects.reindex([1, 2, 3], fill_value="foo")
+    expected = Series([2, 3, "foo"], index=[1, 2, 3], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+    # ------------------------------------------------------------
+    # bools
+    bools = Series([True, False, True])
+
+    result = bools.reindex([1, 2, 3])
+    expected = Series([False, True, np.nan], index=[1, 2, 3], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+    result = bools.reindex([1, 2, 3], fill_value=False)
+    expected = Series([False, True, False], index=[1, 2, 3])
+    tm.assert_series_equal(result, expected)
+
+
+@td.skip_array_manager_not_yet_implemented
+@pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+@pytest.mark.parametrize("fill_value", ["string", 0, Timedelta(0)])
+def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value, using_array_manager):
+    # https://github.com/pandas-dev/pandas/issues/42921
+    if dtype == "timedelta64[ns]" and fill_value == Timedelta(0):
+        # use the scalar that is not compatible with the dtype for this test
+        fill_value = Timestamp(0)
+
+    ser = Series([NaT], dtype=dtype)
+
+    result = ser.reindex([0, 1], fill_value=fill_value)
+    expected = Series([NaT, fill_value], index=[0, 1], dtype=object)
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_datetimeindexes_tz_naive_and_aware():
+    # GH 8306
+    idx = date_range("20131101", tz="America/Chicago", periods=7)
+    newidx = date_range("20131103", periods=10, freq="H")
+    s = Series(range(7), index=idx)
+    msg = (
+        r"Cannot compare dtypes datetime64\[ns, America/Chicago\] "
+        r"and datetime64\[ns\]"
+    )
+    with pytest.raises(TypeError, match=msg):
+        s.reindex(newidx, method="ffill")
+
+
+def test_reindex_empty_series_tz_dtype():
+    # GH 20869
+    result = Series(dtype="datetime64[ns, UTC]").reindex([0, 1])
+    expected = Series([NaT] * 2, dtype="datetime64[ns, UTC]")
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "p_values, o_values, values, expected_values",
+    [
+        (
+            [Period("2019Q1", "Q-DEC"), Period("2019Q2", "Q-DEC")],
+            [Period("2019Q1", "Q-DEC"), Period("2019Q2", "Q-DEC"), "All"],
+            [1.0, 1.0],
+            [1.0, 1.0, np.nan],
+        ),
+        (
+            [Period("2019Q1", "Q-DEC"), Period("2019Q2", "Q-DEC")],
+            [Period("2019Q1", "Q-DEC"), Period("2019Q2", "Q-DEC")],
+            [1.0, 1.0],
+            [1.0, 1.0],
+        ),
+    ],
+)
+def test_reindex_periodindex_with_object(p_values, o_values, values, expected_values):
+    # GH#28337
+    period_index = PeriodIndex(p_values)
+    object_index = Index(o_values)
+
+    ser = Series(values, index=period_index)
+    result = ser.reindex(object_index)
+    expected = Series(expected_values, index=object_index)
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_too_many_args():
+    # GH 40980
+    ser = Series([1, 2])
+    msg = r"reindex\(\) takes from 1 to 2 positional arguments but 3 were given"
+    with pytest.raises(TypeError, match=msg):
+        ser.reindex([2, 3], False)
+
+
+def test_reindex_double_index():
+    # GH 40980
+    ser = Series([1, 2])
+    msg = r"reindex\(\) got multiple values for argument 'index'"
+    with pytest.raises(TypeError, match=msg):
+        ser.reindex([2, 3], index=[3, 4])
+
+
+def test_reindex_no_posargs():
+    # GH 40980
+    ser = Series([1, 2])
+    result = ser.reindex(index=[1, 0])
+    expected = Series([2, 1], index=[1, 0])
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("values", [[["a"], ["x"]], [[], []]])
+def test_reindex_empty_with_level(values):
+    # GH41170
+    ser = Series(
+        range(len(values[0])), index=MultiIndex.from_arrays(values), dtype="object"
+    )
+    result = ser.reindex(np.array(["b"]), level=0)
+    expected = Series(
+        index=MultiIndex(levels=[["b"], values[1]], codes=[[], []]), dtype="object"
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_missing_category():
+    # GH#18185
+    ser = Series([1, 2, 3, 1], dtype="category")
+    msg = r"Cannot setitem on a Categorical with a new category \(-1\)"
+    with pytest.raises(TypeError, match=msg):
+        ser.reindex([1, 2, 3, 4, 5], fill_value=-1)
+
+
+def test_reindexing_with_float64_NA_log():
+    # GH 47055
+    s = Series([1.0, NA], dtype=Float64Dtype())
+    s_reindex = s.reindex(range(3))
+    result = s_reindex.values._data
+    expected = np.array([1, np.nan, np.nan])
+    tm.assert_numpy_array_equal(result, expected)
+    with tm.assert_produces_warning(None):
+        result_log = np.log(s_reindex)
+        expected_log = Series([0, np.nan, np.nan], dtype=Float64Dtype())
+        tm.assert_series_equal(result_log, expected_log)
+
+
+@pytest.mark.parametrize("dtype", ["timedelta64", "datetime64"])
+def test_reindex_expand_nonnano_nat(dtype):
+    # GH 53497
+    ser = Series(np.array([1], dtype=f"{dtype}[s]"))
+    result = ser.reindex(RangeIndex(2))
+    expected = Series(
+        np.array([1, getattr(np, dtype)("nat", "s")], dtype=f"{dtype}[s]")
+    )
+    tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reindex_like.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reindex_like.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f24c778feb1b4556587773f711e21521efc537c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reindex_like.py
@@ -0,0 +1,41 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_reindex_like(datetime_series):
+    other = datetime_series[::2]
+    tm.assert_series_equal(
+        datetime_series.reindex(other.index), datetime_series.reindex_like(other)
+    )
+
+    # GH#7179
+    day1 = datetime(2013, 3, 5)
+    day2 = datetime(2013, 5, 5)
+    day3 = datetime(2014, 3, 5)
+
+    series1 = Series([5, None, None], [day1, day2, day3])
+    series2 = Series([None, None], [day1, day3])
+
+    result = series1.reindex_like(series2, method="pad")
+    expected = Series([5, np.nan], index=[day1, day3])
+    tm.assert_series_equal(result, expected)
+
+
+def test_reindex_like_nearest():
+    ser = Series(np.arange(10, dtype="int64"))
+
+    target = [0.1, 0.9, 1.5, 2.0]
+    other = ser.reindex(target, method="nearest")
+    expected = Series(np.around(target).astype("int64"), target)
+
+    result = ser.reindex_like(other, method="nearest")
+    tm.assert_series_equal(expected, result)
+
+    result = ser.reindex_like(other, method="nearest", tolerance=1)
+    tm.assert_series_equal(expected, result)
+    result = ser.reindex_like(other, method="nearest", tolerance=[1, 2, 3, 4])
+    tm.assert_series_equal(expected, result)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rename.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rename.py
new file mode 100644
index 0000000000000000000000000000000000000000..93c4fbb7f3c46c4cdcd969c1eb4840805e9307d8
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rename.py
@@ -0,0 +1,176 @@
+from datetime import datetime
+import re
+
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestRename:
+    def test_rename(self, datetime_series):
+        ts = datetime_series
+        renamer = lambda x: x.strftime("%Y%m%d")
+        renamed = ts.rename(renamer)
+        assert renamed.index[0] == renamer(ts.index[0])
+
+        # dict
+        rename_dict = dict(zip(ts.index, renamed.index))
+        renamed2 = ts.rename(rename_dict)
+        tm.assert_series_equal(renamed, renamed2)
+
+    def test_rename_partial_dict(self):
+        # partial dict
+        ser = Series(np.arange(4), index=["a", "b", "c", "d"], dtype="int64")
+        renamed = ser.rename({"b": "foo", "d": "bar"})
+        tm.assert_index_equal(renamed.index, Index(["a", "foo", "c", "bar"]))
+
+    def test_rename_retain_index_name(self):
+        # index with name
+        renamer = Series(
+            np.arange(4), index=Index(["a", "b", "c", "d"], name="name"), dtype="int64"
+        )
+        renamed = renamer.rename({})
+        assert renamed.index.name == renamer.index.name
+
+    def test_rename_by_series(self):
+        ser = Series(range(5), name="foo")
+        renamer = Series({1: 10, 2: 20})
+        result = ser.rename(renamer)
+        expected = Series(range(5), index=[0, 10, 20, 3, 4], name="foo")
+        tm.assert_series_equal(result, expected)
+
+    def test_rename_set_name(self):
+        ser = Series(range(4), index=list("abcd"))
+        for name in ["foo", 123, 123.0, datetime(2001, 11, 11), ("foo",)]:
+            result = ser.rename(name)
+            assert result.name == name
+            tm.assert_numpy_array_equal(result.index.values, ser.index.values)
+            assert ser.name is None
+
+    def test_rename_set_name_inplace(self):
+        ser = Series(range(3), index=list("abc"))
+        for name in ["foo", 123, 123.0, datetime(2001, 11, 11), ("foo",)]:
+            ser.rename(name, inplace=True)
+            assert ser.name == name
+
+            exp = np.array(["a", "b", "c"], dtype=np.object_)
+            tm.assert_numpy_array_equal(ser.index.values, exp)
+
+    def test_rename_axis_supported(self):
+        # Supporting axis for compatibility, detailed in GH-18589
+        ser = Series(range(5))
+        ser.rename({}, axis=0)
+        ser.rename({}, axis="index")
+
+        with pytest.raises(ValueError, match="No axis named 5"):
+            ser.rename({}, axis=5)
+
+    def test_rename_inplace(self, datetime_series):
+        renamer = lambda x: x.strftime("%Y%m%d")
+        expected = renamer(datetime_series.index[0])
+
+        datetime_series.rename(renamer, inplace=True)
+        assert datetime_series.index[0] == expected
+
+    def test_rename_with_custom_indexer(self):
+        # GH 27814
+        class MyIndexer:
+            pass
+
+        ix = MyIndexer()
+        ser = Series([1, 2, 3]).rename(ix)
+        assert ser.name is ix
+
+    def test_rename_with_custom_indexer_inplace(self):
+        # GH 27814
+        class MyIndexer:
+            pass
+
+        ix = MyIndexer()
+        ser = Series([1, 2, 3])
+        ser.rename(ix, inplace=True)
+        assert ser.name is ix
+
+    def test_rename_callable(self):
+        # GH 17407
+        ser = Series(range(1, 6), index=Index(range(2, 7), name="IntIndex"))
+        result = ser.rename(str)
+        expected = ser.rename(lambda i: str(i))
+        tm.assert_series_equal(result, expected)
+
+        assert result.name == expected.name
+
+    def test_rename_none(self):
+        # GH 40977
+        ser = Series([1, 2], name="foo")
+        result = ser.rename(None)
+        expected = Series([1, 2])
+        tm.assert_series_equal(result, expected)
+
+    def test_rename_series_with_multiindex(self):
+        # issue #43659
+        arrays = [
+            ["bar", "baz", "baz", "foo", "qux"],
+            ["one", "one", "two", "two", "one"],
+        ]
+
+        index = MultiIndex.from_arrays(arrays, names=["first", "second"])
+        ser = Series(np.ones(5), index=index)
+        result = ser.rename(index={"one": "yes"}, level="second", errors="raise")
+
+        arrays_expected = [
+            ["bar", "baz", "baz", "foo", "qux"],
+            ["yes", "yes", "two", "two", "yes"],
+        ]
+
+        index_expected = MultiIndex.from_arrays(
+            arrays_expected, names=["first", "second"]
+        )
+        series_expected = Series(np.ones(5), index=index_expected)
+
+        tm.assert_series_equal(result, series_expected)
+
+    def test_rename_series_with_multiindex_keeps_ea_dtypes(self):
+        # GH21055
+        arrays = [
+            Index([1, 2, 3], dtype="Int64").astype("category"),
+            Index([1, 2, 3], dtype="Int64"),
+        ]
+        mi = MultiIndex.from_arrays(arrays, names=["A", "B"])
+        ser = Series(1, index=mi)
+        result = ser.rename({1: 4}, level=1)
+
+        arrays_expected = [
+            Index([1, 2, 3], dtype="Int64").astype("category"),
+            Index([4, 2, 3], dtype="Int64"),
+        ]
+        mi_expected = MultiIndex.from_arrays(arrays_expected, names=["A", "B"])
+        expected = Series(1, index=mi_expected)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_rename_error_arg(self):
+        # GH 46889
+        ser = Series(["foo", "bar"])
+        match = re.escape("[2] not found in axis")
+        with pytest.raises(KeyError, match=match):
+            ser.rename({2: 9}, errors="raise")
+
+    def test_rename_copy_false(self, using_copy_on_write):
+        # GH 46889
+        ser = Series(["foo", "bar"])
+        ser_orig = ser.copy()
+        shallow_copy = ser.rename({1: 9}, copy=False)
+        ser[0] = "foobar"
+        if using_copy_on_write:
+            assert ser_orig[0] == shallow_copy[0]
+            assert ser_orig[1] == shallow_copy[9]
+        else:
+            assert ser[0] == shallow_copy[0]
+            assert ser[1] == shallow_copy[9]
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rename_axis.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rename_axis.py
new file mode 100644
index 0000000000000000000000000000000000000000..58c095d697ede213be5c730e305bf1789810ac4a
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_rename_axis.py
@@ -0,0 +1,47 @@
+import pytest
+
+from pandas import (
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestSeriesRenameAxis:
+    def test_rename_axis_mapper(self):
+        # GH 19978
+        mi = MultiIndex.from_product([["a", "b", "c"], [1, 2]], names=["ll", "nn"])
+        ser = Series(list(range(len(mi))), index=mi)
+
+        result = ser.rename_axis(index={"ll": "foo"})
+        assert result.index.names == ["foo", "nn"]
+
+        result = ser.rename_axis(index=str.upper, axis=0)
+        assert result.index.names == ["LL", "NN"]
+
+        result = ser.rename_axis(index=["foo", "goo"])
+        assert result.index.names == ["foo", "goo"]
+
+        with pytest.raises(TypeError, match="unexpected"):
+            ser.rename_axis(columns="wrong")
+
+    def test_rename_axis_inplace(self, datetime_series):
+        # GH 15704
+        expected = datetime_series.rename_axis("foo")
+        result = datetime_series
+        no_return = result.rename_axis("foo", inplace=True)
+
+        assert no_return is None
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("kwargs", [{"mapper": None}, {"index": None}, {}])
+    def test_rename_axis_none(self, kwargs):
+        # GH 25034
+        index = Index(list("abc"), name="foo")
+        ser = Series([1, 2, 3], index=index)
+
+        result = ser.rename_axis(**kwargs)
+        expected_index = index.rename(None) if kwargs else index
+        expected = Series([1, 2, 3], index=expected_index)
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_repeat.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_repeat.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ecc8052ff49c150444cf395b68e6163fb761775
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_repeat.py
@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestRepeat:
+    def test_repeat(self):
+        ser = Series(np.random.default_rng(2).standard_normal(3), index=["a", "b", "c"])
+
+        reps = ser.repeat(5)
+        exp = Series(ser.values.repeat(5), index=ser.index.values.repeat(5))
+        tm.assert_series_equal(reps, exp)
+
+        to_rep = [2, 3, 4]
+        reps = ser.repeat(to_rep)
+        exp = Series(ser.values.repeat(to_rep), index=ser.index.values.repeat(to_rep))
+        tm.assert_series_equal(reps, exp)
+
+    def test_numpy_repeat(self):
+        ser = Series(np.arange(3), name="x")
+        expected = Series(
+            ser.values.repeat(2), name="x", index=ser.index.values.repeat(2)
+        )
+        tm.assert_series_equal(np.repeat(ser, 2), expected)
+
+        msg = "the 'axis' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.repeat(ser, 2, axis=0)
+
+    def test_repeat_with_multiindex(self):
+        # GH#9361, fixed by  GH#7891
+        m_idx = MultiIndex.from_tuples([(1, 2), (3, 4), (5, 6), (7, 8)])
+        data = ["a", "b", "c", "d"]
+        m_df = Series(data, index=m_idx)
+        assert m_df.repeat(3).shape == (3 * len(data),)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_replace.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_replace.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec9db8c3830d62079541a519261a21039bcfdc4f
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_replace.py
@@ -0,0 +1,770 @@
+import re
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.arrays import IntervalArray
+
+
+class TestSeriesReplace:
+    def test_replace_explicit_none(self):
+        # GH#36984 if the user explicitly passes value=None, give it to them
+        ser = pd.Series([0, 0, ""], dtype=object)
+        result = ser.replace("", None)
+        expected = pd.Series([0, 0, None], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        # Cast column 2 to object to avoid implicit cast when setting entry to ""
+        df = pd.DataFrame(np.zeros((3, 3))).astype({2: object})
+        df.iloc[2, 2] = ""
+        result = df.replace("", None)
+        expected = pd.DataFrame(
+            {
+                0: np.zeros(3),
+                1: np.zeros(3),
+                2: np.array([0.0, 0.0, None], dtype=object),
+            }
+        )
+        assert expected.iloc[2, 2] is None
+        tm.assert_frame_equal(result, expected)
+
+        # GH#19998 same thing with object dtype
+        ser = pd.Series([10, 20, 30, "a", "a", "b", "a"])
+        result = ser.replace("a", None)
+        expected = pd.Series([10, 20, 30, None, None, "b", None])
+        assert expected.iloc[-1] is None
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_noop_doesnt_downcast(self):
+        # GH#44498
+        ser = pd.Series([None, None, pd.Timestamp("2021-12-16 17:31")], dtype=object)
+        res = ser.replace({np.nan: None})  # should be a no-op
+        tm.assert_series_equal(res, ser)
+        assert res.dtype == object
+
+        # same thing but different calling convention
+        res = ser.replace(np.nan, None)
+        tm.assert_series_equal(res, ser)
+        assert res.dtype == object
+
+    def test_replace(self):
+        N = 100
+        ser = pd.Series(np.random.default_rng(2).standard_normal(N))
+        ser[0:4] = np.nan
+        ser[6:10] = 0
+
+        # replace list with a single value
+        return_value = ser.replace([np.nan], -1, inplace=True)
+        assert return_value is None
+
+        exp = ser.fillna(-1)
+        tm.assert_series_equal(ser, exp)
+
+        rs = ser.replace(0.0, np.nan)
+        ser[ser == 0.0] = np.nan
+        tm.assert_series_equal(rs, ser)
+
+        ser = pd.Series(
+            np.fabs(np.random.default_rng(2).standard_normal(N)),
+            tm.makeDateIndex(N),
+            dtype=object,
+        )
+        ser[:5] = np.nan
+        ser[6:10] = "foo"
+        ser[20:30] = "bar"
+
+        # replace list with a single value
+        rs = ser.replace([np.nan, "foo", "bar"], -1)
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -1).all()
+        assert (rs[20:30] == -1).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values
+        rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -2).all()
+        assert (rs[20:30] == -3).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values with 2 lists
+        rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
+        tm.assert_series_equal(rs, rs2)
+
+        # replace inplace
+        return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        assert return_value is None
+
+        assert (ser[:5] == -1).all()
+        assert (ser[6:10] == -1).all()
+        assert (ser[20:30] == -1).all()
+
+    def test_replace_nan_with_inf(self):
+        ser = pd.Series([np.nan, 0, np.inf])
+        tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
+
+        ser = pd.Series([np.nan, 0, "foo", "bar", np.inf, None, pd.NaT])
+        tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
+        filled = ser.copy()
+        filled[4] = 0
+        tm.assert_series_equal(ser.replace(np.inf, 0), filled)
+
+    def test_replace_listlike_value_listlike_target(self, datetime_series):
+        ser = pd.Series(datetime_series.index)
+        tm.assert_series_equal(ser.replace(np.nan, 0), ser.fillna(0))
+
+        # malformed
+        msg = r"Replacement lists must match in length\. Expecting 3 got 2"
+        with pytest.raises(ValueError, match=msg):
+            ser.replace([1, 2, 3], [np.nan, 0])
+
+        # ser is dt64 so can't hold 1 or 2, so this replace is a no-op
+        result = ser.replace([1, 2], [np.nan, 0])
+        tm.assert_series_equal(result, ser)
+
+        ser = pd.Series([0, 1, 2, 3, 4])
+        result = ser.replace([0, 1, 2, 3, 4], [4, 3, 2, 1, 0])
+        tm.assert_series_equal(result, pd.Series([4, 3, 2, 1, 0]))
+
+    def test_replace_gh5319(self):
+        # API change from 0.12?
+        # GH 5319
+        ser = pd.Series([0, np.nan, 2, 3, 4])
+        expected = ser.ffill()
+        msg = (
+            "Series.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.replace([np.nan])
+        tm.assert_series_equal(result, expected)
+
+        ser = pd.Series([0, np.nan, 2, 3, 4])
+        expected = ser.ffill()
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = ser.replace(np.nan)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_datetime64(self):
+        # GH 5797
+        ser = pd.Series(pd.date_range("20130101", periods=5))
+        expected = ser.copy()
+        expected.loc[2] = pd.Timestamp("20120101")
+        result = ser.replace({pd.Timestamp("20130103"): pd.Timestamp("20120101")})
+        tm.assert_series_equal(result, expected)
+        result = ser.replace(pd.Timestamp("20130103"), pd.Timestamp("20120101"))
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_nat_with_tz(self):
+        # GH 11792: Test with replacing NaT in a list with tz data
+        ts = pd.Timestamp("2015/01/01", tz="UTC")
+        s = pd.Series([pd.NaT, pd.Timestamp("2015/01/01", tz="UTC")])
+        result = s.replace([np.nan, pd.NaT], pd.Timestamp.min)
+        expected = pd.Series([pd.Timestamp.min, ts], dtype=object)
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_timedelta_td64(self):
+        tdi = pd.timedelta_range(0, periods=5)
+        ser = pd.Series(tdi)
+
+        # Using a single dict argument means we go through replace_list
+        result = ser.replace({ser[1]: ser[3]})
+
+        expected = pd.Series([ser[0], ser[3], ser[2], ser[3], ser[4]])
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_with_single_list(self):
+        ser = pd.Series([0, 1, 2, 3, 4])
+        msg2 = (
+            "Series.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            result = ser.replace([1, 2, 3])
+        tm.assert_series_equal(result, pd.Series([0, 0, 0, 0, 4]))
+
+        s = ser.copy()
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            return_value = s.replace([1, 2, 3], inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(s, pd.Series([0, 0, 0, 0, 4]))
+
+        # make sure things don't get corrupted when fillna call fails
+        s = ser.copy()
+        msg = (
+            r"Invalid fill method\. Expecting pad \(ffill\) or backfill "
+            r"\(bfill\)\. Got crash_cymbal"
+        )
+        msg3 = "The 'method' keyword in Series.replace is deprecated"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg3):
+                return_value = s.replace([1, 2, 3], inplace=True, method="crash_cymbal")
+            assert return_value is None
+        tm.assert_series_equal(s, ser)
+
+    def test_replace_mixed_types(self):
+        ser = pd.Series(np.arange(5), dtype="int64")
+
+        def check_replace(to_rep, val, expected):
+            sc = ser.copy()
+            result = ser.replace(to_rep, val)
+            return_value = sc.replace(to_rep, val, inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(expected, result)
+            tm.assert_series_equal(expected, sc)
+
+        # 3.0 can still be held in our int64 series, so we do not upcast GH#44940
+        tr, v = [3], [3.0]
+        check_replace(tr, v, ser)
+        # Note this matches what we get with the scalars 3 and 3.0
+        check_replace(tr[0], v[0], ser)
+
+        # MUST upcast to float
+        e = pd.Series([0, 1, 2, 3.5, 4])
+        tr, v = [3], [3.5]
+        check_replace(tr, v, e)
+
+        # casts to object
+        e = pd.Series([0, 1, 2, 3.5, "a"])
+        tr, v = [3, 4], [3.5, "a"]
+        check_replace(tr, v, e)
+
+        # again casts to object
+        e = pd.Series([0, 1, 2, 3.5, pd.Timestamp("20130101")])
+        tr, v = [3, 4], [3.5, pd.Timestamp("20130101")]
+        check_replace(tr, v, e)
+
+        # casts to object
+        e = pd.Series([0, 1, 2, 3.5, True], dtype="object")
+        tr, v = [3, 4], [3.5, True]
+        check_replace(tr, v, e)
+
+        # test an object with dates + floats + integers + strings
+        dr = pd.Series(pd.date_range("1/1/2001", "1/10/2001", freq="D"))
+        result = dr.astype(object).replace([dr[0], dr[1], dr[2]], [1.0, 2, "a"])
+        expected = pd.Series([1.0, 2, "a"] + dr[3:].tolist(), dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_bool_with_string_no_op(self):
+        s = pd.Series([True, False, True])
+        result = s.replace("fun", "in-the-sun")
+        tm.assert_series_equal(s, result)
+
+    def test_replace_bool_with_string(self):
+        # nonexistent elements
+        s = pd.Series([True, False, True])
+        result = s.replace(True, "2u")
+        expected = pd.Series(["2u", False, "2u"])
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_bool_with_bool(self):
+        s = pd.Series([True, False, True])
+        result = s.replace(True, False)
+        expected = pd.Series([False] * len(s))
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_with_dict_with_bool_keys(self):
+        s = pd.Series([True, False, True])
+        result = s.replace({"asdf": "asdb", True: "yes"})
+        expected = pd.Series(["yes", False, "yes"])
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_Int_with_na(self, any_int_ea_dtype):
+        # GH 38267
+        result = pd.Series([0, None], dtype=any_int_ea_dtype).replace(0, pd.NA)
+        expected = pd.Series([pd.NA, pd.NA], dtype=any_int_ea_dtype)
+        tm.assert_series_equal(result, expected)
+        result = pd.Series([0, 1], dtype=any_int_ea_dtype).replace(0, pd.NA)
+        result.replace(1, pd.NA, inplace=True)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace2(self):
+        N = 100
+        ser = pd.Series(
+            np.fabs(np.random.default_rng(2).standard_normal(N)),
+            tm.makeDateIndex(N),
+            dtype=object,
+        )
+        ser[:5] = np.nan
+        ser[6:10] = "foo"
+        ser[20:30] = "bar"
+
+        # replace list with a single value
+        rs = ser.replace([np.nan, "foo", "bar"], -1)
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -1).all()
+        assert (rs[20:30] == -1).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values
+        rs = ser.replace({np.nan: -1, "foo": -2, "bar": -3})
+
+        assert (rs[:5] == -1).all()
+        assert (rs[6:10] == -2).all()
+        assert (rs[20:30] == -3).all()
+        assert (pd.isna(ser[:5])).all()
+
+        # replace with different values with 2 lists
+        rs2 = ser.replace([np.nan, "foo", "bar"], [-1, -2, -3])
+        tm.assert_series_equal(rs, rs2)
+
+        # replace inplace
+        return_value = ser.replace([np.nan, "foo", "bar"], -1, inplace=True)
+        assert return_value is None
+        assert (ser[:5] == -1).all()
+        assert (ser[6:10] == -1).all()
+        assert (ser[20:30] == -1).all()
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    def test_replace_cascade(self, inplace):
+        # Test that replaced values are not replaced again
+        # GH #50778
+        ser = pd.Series([1, 2, 3])
+        expected = pd.Series([2, 3, 4])
+
+        res = ser.replace([1, 2, 3], [2, 3, 4], inplace=inplace)
+        if inplace:
+            tm.assert_series_equal(ser, expected)
+        else:
+            tm.assert_series_equal(res, expected)
+
+    def test_replace_with_dictlike_and_string_dtype(self, nullable_string_dtype):
+        # GH 32621, GH#44940
+        ser = pd.Series(["one", "two", np.nan], dtype=nullable_string_dtype)
+        expected = pd.Series(["1", "2", np.nan], dtype=nullable_string_dtype)
+        result = ser.replace({"one": "1", "two": "2"})
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_with_empty_dictlike(self):
+        # GH 15289
+        s = pd.Series(list("abcd"))
+        tm.assert_series_equal(s, s.replace({}))
+
+        empty_series = pd.Series([])
+        tm.assert_series_equal(s, s.replace(empty_series))
+
+    def test_replace_string_with_number(self):
+        # GH 15743
+        s = pd.Series([1, 2, 3])
+        result = s.replace("2", np.nan)
+        expected = pd.Series([1, 2, 3])
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_replacer_equals_replacement(self):
+        # GH 20656
+        # make sure all replacers are matching against original values
+        s = pd.Series(["a", "b"])
+        expected = pd.Series(["b", "a"])
+        result = s.replace({"a": "b", "b": "a"})
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_unicode_with_number(self):
+        # GH 15743
+        s = pd.Series([1, 2, 3])
+        result = s.replace("2", np.nan)
+        expected = pd.Series([1, 2, 3])
+        tm.assert_series_equal(expected, result)
+
+    def test_replace_mixed_types_with_string(self):
+        # Testing mixed
+        s = pd.Series([1, 2, 3, "4", 4, 5])
+        result = s.replace([2, "4"], np.nan)
+        expected = pd.Series([1, np.nan, 3, np.nan, 4, 5])
+        tm.assert_series_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "categorical, numeric",
+        [
+            (pd.Categorical(["A"], categories=["A", "B"]), [1]),
+            (pd.Categorical(["A", "B"], categories=["A", "B"]), [1, 2]),
+        ],
+    )
+    def test_replace_categorical(self, categorical, numeric):
+        # GH 24971, GH#23305
+        ser = pd.Series(categorical)
+        result = ser.replace({"A": 1, "B": 2})
+        expected = pd.Series(numeric).astype("category")
+        if 2 not in expected.cat.categories:
+            # i.e. categories should be [1, 2] even if there are no "B"s present
+            # GH#44940
+            expected = expected.cat.add_categories(2)
+        tm.assert_series_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "data, data_exp", [(["a", "b", "c"], ["b", "b", "c"]), (["a"], ["b"])]
+    )
+    def test_replace_categorical_inplace(self, data, data_exp):
+        # GH 53358
+        result = pd.Series(data, dtype="category")
+        result.replace(to_replace="a", value="b", inplace=True)
+        expected = pd.Series(data_exp, dtype="category")
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_categorical_single(self):
+        # GH 26988
+        dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+        s = pd.Series(dti)
+        c = s.astype("category")
+
+        expected = c.copy()
+        expected = expected.cat.add_categories("foo")
+        expected[2] = "foo"
+        expected = expected.cat.remove_unused_categories()
+        assert c[2] != "foo"
+
+        result = c.replace(c[2], "foo")
+        tm.assert_series_equal(expected, result)
+        assert c[2] != "foo"  # ensure non-inplace call does not alter original
+
+        return_value = c.replace(c[2], "foo", inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(expected, c)
+
+        first_value = c[0]
+        return_value = c.replace(c[1], c[0], inplace=True)
+        assert return_value is None
+        assert c[0] == c[1] == first_value  # test replacing with existing value
+
+    def test_replace_with_no_overflowerror(self):
+        # GH 25616
+        # casts to object without Exception from OverflowError
+        s = pd.Series([0, 1, 2, 3, 4])
+        result = s.replace([3], ["100000000000000000000"])
+        expected = pd.Series([0, 1, 2, "100000000000000000000", 4])
+        tm.assert_series_equal(result, expected)
+
+        s = pd.Series([0, "100000000000000000000", "100000000000000000001"])
+        result = s.replace(["100000000000000000000"], [1])
+        expected = pd.Series([0, 1, "100000000000000000001"])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, to_replace, exp",
+        [
+            ([1, 2, 3], {1: 2, 2: 3, 3: 4}, [2, 3, 4]),
+            (["1", "2", "3"], {"1": "2", "2": "3", "3": "4"}, ["2", "3", "4"]),
+        ],
+    )
+    def test_replace_commutative(self, ser, to_replace, exp):
+        # GH 16051
+        # DataFrame.replace() overwrites when values are non-numeric
+
+        series = pd.Series(ser)
+
+        expected = pd.Series(exp)
+        result = series.replace(to_replace)
+
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ser, exp", [([1, 2, 3], [1, True, 3]), (["x", 2, 3], ["x", True, 3])]
+    )
+    def test_replace_no_cast(self, ser, exp):
+        # GH 9113
+        # BUG: replace int64 dtype with bool coerces to int64
+
+        series = pd.Series(ser)
+        result = series.replace(2, True)
+        expected = pd.Series(exp)
+
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_invalid_to_replace(self):
+        # GH 18634
+        # API: replace() should raise an exception if invalid argument is given
+        series = pd.Series(["a", "b", "c "])
+        msg = (
+            r"Expecting 'to_replace' to be either a scalar, array-like, "
+            r"dict or None, got invalid type.*"
+        )
+        msg2 = (
+            "Series.replace without 'value' and with non-dict-like "
+            "'to_replace' is deprecated"
+        )
+        with pytest.raises(TypeError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                series.replace(lambda x: x.strip())
+
+    @pytest.mark.parametrize("frame", [False, True])
+    def test_replace_nonbool_regex(self, frame):
+        obj = pd.Series(["a", "b", "c "])
+        if frame:
+            obj = obj.to_frame()
+
+        msg = "'to_replace' must be 'None' if 'regex' is not a bool"
+        with pytest.raises(ValueError, match=msg):
+            obj.replace(to_replace=["a"], regex="foo")
+
+    @pytest.mark.parametrize("frame", [False, True])
+    def test_replace_empty_copy(self, frame):
+        obj = pd.Series([], dtype=np.float64)
+        if frame:
+            obj = obj.to_frame()
+
+        res = obj.replace(4, 5, inplace=True)
+        assert res is None
+
+        res = obj.replace(4, 5, inplace=False)
+        tm.assert_equal(res, obj)
+        assert res is not obj
+
+    def test_replace_only_one_dictlike_arg(self, fixed_now_ts):
+        # GH#33340
+
+        ser = pd.Series([1, 2, "A", fixed_now_ts, True])
+        to_replace = {0: 1, 2: "A"}
+        value = "foo"
+        msg = "Series.replace cannot use dict-like to_replace and non-None value"
+        with pytest.raises(ValueError, match=msg):
+            ser.replace(to_replace, value)
+
+        to_replace = 1
+        value = {0: "foo", 2: "bar"}
+        msg = "Series.replace cannot use dict-value and non-None to_replace"
+        with pytest.raises(ValueError, match=msg):
+            ser.replace(to_replace, value)
+
+    def test_replace_extension_other(self, frame_or_series):
+        # https://github.com/pandas-dev/pandas/issues/34530
+        obj = frame_or_series(pd.array([1, 2, 3], dtype="Int64"))
+        result = obj.replace("", "")  # no exception
+        # should not have changed dtype
+        tm.assert_equal(obj, result)
+
+    def _check_replace_with_method(self, ser: pd.Series):
+        df = ser.to_frame()
+
+        msg1 = "The 'method' keyword in Series.replace is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg1):
+            res = ser.replace(ser[1], method="pad")
+        expected = pd.Series([ser[0], ser[0]] + list(ser[2:]), dtype=ser.dtype)
+        tm.assert_series_equal(res, expected)
+
+        msg2 = "The 'method' keyword in DataFrame.replace is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            res_df = df.replace(ser[1], method="pad")
+        tm.assert_frame_equal(res_df, expected.to_frame())
+
+        ser2 = ser.copy()
+        with tm.assert_produces_warning(FutureWarning, match=msg1):
+            res2 = ser2.replace(ser[1], method="pad", inplace=True)
+        assert res2 is None
+        tm.assert_series_equal(ser2, expected)
+
+        with tm.assert_produces_warning(FutureWarning, match=msg2):
+            res_df2 = df.replace(ser[1], method="pad", inplace=True)
+        assert res_df2 is None
+        tm.assert_frame_equal(df, expected.to_frame())
+
+    def test_replace_ea_dtype_with_method(self, any_numeric_ea_dtype):
+        arr = pd.array([1, 2, pd.NA, 4], dtype=any_numeric_ea_dtype)
+        ser = pd.Series(arr)
+
+        self._check_replace_with_method(ser)
+
+    @pytest.mark.parametrize("as_categorical", [True, False])
+    def test_replace_interval_with_method(self, as_categorical):
+        # in particular interval that can't hold NA
+
+        idx = pd.IntervalIndex.from_breaks(range(4))
+        ser = pd.Series(idx)
+        if as_categorical:
+            ser = ser.astype("category")
+
+        self._check_replace_with_method(ser)
+
+    @pytest.mark.parametrize("as_period", [True, False])
+    @pytest.mark.parametrize("as_categorical", [True, False])
+    def test_replace_datetimelike_with_method(self, as_period, as_categorical):
+        idx = pd.date_range("2016-01-01", periods=5, tz="US/Pacific")
+        if as_period:
+            idx = idx.tz_localize(None).to_period("D")
+
+        ser = pd.Series(idx)
+        ser.iloc[-2] = pd.NaT
+        if as_categorical:
+            ser = ser.astype("category")
+
+        self._check_replace_with_method(ser)
+
+    def test_replace_with_compiled_regex(self):
+        # https://github.com/pandas-dev/pandas/issues/35680
+        s = pd.Series(["a", "b", "c"])
+        regex = re.compile("^a$")
+        result = s.replace({regex: "z"}, regex=True)
+        expected = pd.Series(["z", "b", "c"])
+        tm.assert_series_equal(result, expected)
+
+    def test_pandas_replace_na(self):
+        # GH#43344
+        ser = pd.Series(["AA", "BB", "CC", "DD", "EE", "", pd.NA], dtype="string")
+        regex_mapping = {
+            "AA": "CC",
+            "BB": "CC",
+            "EE": "CC",
+            "CC": "CC-REPL",
+        }
+        result = ser.replace(regex_mapping, regex=True)
+        exp = pd.Series(["CC", "CC", "CC-REPL", "DD", "CC", "", pd.NA], dtype="string")
+        tm.assert_series_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "dtype, input_data, to_replace, expected_data",
+        [
+            ("bool", [True, False], {True: False}, [False, False]),
+            ("int64", [1, 2], {1: 10, 2: 20}, [10, 20]),
+            ("Int64", [1, 2], {1: 10, 2: 20}, [10, 20]),
+            ("float64", [1.1, 2.2], {1.1: 10.1, 2.2: 20.5}, [10.1, 20.5]),
+            ("Float64", [1.1, 2.2], {1.1: 10.1, 2.2: 20.5}, [10.1, 20.5]),
+            ("string", ["one", "two"], {"one": "1", "two": "2"}, ["1", "2"]),
+            (
+                pd.IntervalDtype("int64"),
+                IntervalArray([pd.Interval(1, 2), pd.Interval(2, 3)]),
+                {pd.Interval(1, 2): pd.Interval(10, 20)},
+                IntervalArray([pd.Interval(10, 20), pd.Interval(2, 3)]),
+            ),
+            (
+                pd.IntervalDtype("float64"),
+                IntervalArray([pd.Interval(1.0, 2.7), pd.Interval(2.8, 3.1)]),
+                {pd.Interval(1.0, 2.7): pd.Interval(10.6, 20.8)},
+                IntervalArray([pd.Interval(10.6, 20.8), pd.Interval(2.8, 3.1)]),
+            ),
+            (
+                pd.PeriodDtype("M"),
+                [pd.Period("2020-05", freq="M")],
+                {pd.Period("2020-05", freq="M"): pd.Period("2020-06", freq="M")},
+                [pd.Period("2020-06", freq="M")],
+            ),
+        ],
+    )
+    def test_replace_dtype(self, dtype, input_data, to_replace, expected_data):
+        # GH#33484
+        ser = pd.Series(input_data, dtype=dtype)
+        result = ser.replace(to_replace)
+        expected = pd.Series(expected_data, dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_string_dtype(self):
+        # GH#40732, GH#44940
+        ser = pd.Series(["one", "two", np.nan], dtype="string")
+        res = ser.replace({"one": "1", "two": "2"})
+        expected = pd.Series(["1", "2", np.nan], dtype="string")
+        tm.assert_series_equal(res, expected)
+
+        # GH#31644
+        ser2 = pd.Series(["A", np.nan], dtype="string")
+        res2 = ser2.replace("A", "B")
+        expected2 = pd.Series(["B", np.nan], dtype="string")
+        tm.assert_series_equal(res2, expected2)
+
+        ser3 = pd.Series(["A", "B"], dtype="string")
+        res3 = ser3.replace("A", pd.NA)
+        expected3 = pd.Series([pd.NA, "B"], dtype="string")
+        tm.assert_series_equal(res3, expected3)
+
+    def test_replace_string_dtype_list_to_replace(self):
+        # GH#41215, GH#44940
+        ser = pd.Series(["abc", "def"], dtype="string")
+        res = ser.replace(["abc", "any other string"], "xyz")
+        expected = pd.Series(["xyz", "def"], dtype="string")
+        tm.assert_series_equal(res, expected)
+
+    def test_replace_string_dtype_regex(self):
+        # GH#31644
+        ser = pd.Series(["A", "B"], dtype="string")
+        res = ser.replace(r".", "C", regex=True)
+        expected = pd.Series(["C", "C"], dtype="string")
+        tm.assert_series_equal(res, expected)
+
+    def test_replace_nullable_numeric(self):
+        # GH#40732, GH#44940
+
+        floats = pd.Series([1.0, 2.0, 3.999, 4.4], dtype=pd.Float64Dtype())
+        assert floats.replace({1.0: 9}).dtype == floats.dtype
+        assert floats.replace(1.0, 9).dtype == floats.dtype
+        assert floats.replace({1.0: 9.0}).dtype == floats.dtype
+        assert floats.replace(1.0, 9.0).dtype == floats.dtype
+
+        res = floats.replace(to_replace=[1.0, 2.0], value=[9.0, 10.0])
+        assert res.dtype == floats.dtype
+
+        ints = pd.Series([1, 2, 3, 4], dtype=pd.Int64Dtype())
+        assert ints.replace({1: 9}).dtype == ints.dtype
+        assert ints.replace(1, 9).dtype == ints.dtype
+        assert ints.replace({1: 9.0}).dtype == ints.dtype
+        assert ints.replace(1, 9.0).dtype == ints.dtype
+
+        # nullable (for now) raises instead of casting
+        with pytest.raises(TypeError, match="Invalid value"):
+            ints.replace({1: 9.5})
+        with pytest.raises(TypeError, match="Invalid value"):
+            ints.replace(1, 9.5)
+
+    @pytest.mark.parametrize("regex", [False, True])
+    def test_replace_regex_dtype_series(self, regex):
+        # GH-48644
+        series = pd.Series(["0"])
+        expected = pd.Series([1])
+        result = series.replace(to_replace="0", value=1, regex=regex)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_different_int_types(self, any_int_numpy_dtype):
+        # GH#45311
+        labs = pd.Series([1, 1, 1, 0, 0, 2, 2, 2], dtype=any_int_numpy_dtype)
+
+        maps = pd.Series([0, 2, 1], dtype=any_int_numpy_dtype)
+        map_dict = dict(zip(maps.values, maps.index))
+
+        result = labs.replace(map_dict)
+        expected = labs.replace({0: 0, 2: 1, 1: 2})
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [2, np.nan, 2.0])
+    def test_replace_value_none_dtype_numeric(self, val):
+        # GH#48231
+        ser = pd.Series([1, val])
+        result = ser.replace(val, None)
+        expected = pd.Series([1, None], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+    def test_replace_change_dtype_series(self):
+        # GH#25797
+        df = pd.DataFrame.from_dict({"Test": ["0.5", True, "0.6"]})
+        df["Test"] = df["Test"].replace([True], [np.nan])
+        expected = pd.DataFrame.from_dict({"Test": ["0.5", np.nan, "0.6"]})
+        tm.assert_frame_equal(df, expected)
+
+        df = pd.DataFrame.from_dict({"Test": ["0.5", None, "0.6"]})
+        df["Test"] = df["Test"].replace([None], [np.nan])
+        tm.assert_frame_equal(df, expected)
+
+        df = pd.DataFrame.from_dict({"Test": ["0.5", None, "0.6"]})
+        df["Test"] = df["Test"].fillna(np.nan)
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize("dtype", ["object", "Int64"])
+    def test_replace_na_in_obj_column(self, dtype):
+        # GH#47480
+        ser = pd.Series([0, 1, pd.NA], dtype=dtype)
+        expected = pd.Series([0, 2, pd.NA], dtype=dtype)
+        result = ser.replace(to_replace=1, value=2)
+        tm.assert_series_equal(result, expected)
+
+        ser.replace(to_replace=1, value=2, inplace=True)
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize("val", [0, 0.5])
+    def test_replace_numeric_column_with_na(self, val):
+        # GH#50758
+        ser = pd.Series([val, 1])
+        expected = pd.Series([val, pd.NA])
+        result = ser.replace(to_replace=1, value=pd.NA)
+        tm.assert_series_equal(result, expected)
+
+        ser.replace(to_replace=1, value=pd.NA, inplace=True)
+        tm.assert_series_equal(ser, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reset_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reset_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..db36221d8f51009a7b0a9641d83f513434ca475e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_reset_index.py
@@ -0,0 +1,196 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    RangeIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestResetIndex:
+    def test_reset_index_dti_round_trip(self):
+        dti = date_range(start="1/1/2001", end="6/1/2001", freq="D")._with_freq(None)
+        d1 = DataFrame({"v": np.random.default_rng(2).random(len(dti))}, index=dti)
+        d2 = d1.reset_index()
+        assert d2.dtypes.iloc[0] == np.dtype("M8[ns]")
+        d3 = d2.set_index("index")
+        tm.assert_frame_equal(d1, d3, check_names=False)
+
+        # GH#2329
+        stamp = datetime(2012, 11, 22)
+        df = DataFrame([[stamp, 12.1]], columns=["Date", "Value"])
+        df = df.set_index("Date")
+
+        assert df.index[0] == stamp
+        assert df.reset_index()["Date"].iloc[0] == stamp
+
+    def test_reset_index(self):
+        df = tm.makeDataFrame()[:5]
+        ser = df.stack(future_stack=True)
+        ser.index.names = ["hash", "category"]
+
+        ser.name = "value"
+        df = ser.reset_index()
+        assert "value" in df
+
+        df = ser.reset_index(name="value2")
+        assert "value2" in df
+
+        # check inplace
+        s = ser.reset_index(drop=True)
+        s2 = ser
+        return_value = s2.reset_index(drop=True, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(s, s2)
+
+        # level
+        index = MultiIndex(
+            levels=[["bar"], ["one", "two", "three"], [0, 1]],
+            codes=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+        )
+        s = Series(np.random.default_rng(2).standard_normal(6), index=index)
+        rs = s.reset_index(level=1)
+        assert len(rs.columns) == 2
+
+        rs = s.reset_index(level=[0, 2], drop=True)
+        tm.assert_index_equal(rs.index, Index(index.get_level_values(1)))
+        assert isinstance(rs, Series)
+
+    def test_reset_index_name(self):
+        s = Series([1, 2, 3], index=Index(range(3), name="x"))
+        assert s.reset_index().index.name is None
+        assert s.reset_index(drop=True).index.name is None
+
+    def test_reset_index_level(self):
+        df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["A", "B", "C"])
+
+        for levels in ["A", "B"], [0, 1]:
+            # With MultiIndex
+            s = df.set_index(["A", "B"])["C"]
+
+            result = s.reset_index(level=levels[0])
+            tm.assert_frame_equal(result, df.set_index("B"))
+
+            result = s.reset_index(level=levels[:1])
+            tm.assert_frame_equal(result, df.set_index("B"))
+
+            result = s.reset_index(level=levels)
+            tm.assert_frame_equal(result, df)
+
+            result = df.set_index(["A", "B"]).reset_index(level=levels, drop=True)
+            tm.assert_frame_equal(result, df[["C"]])
+
+            with pytest.raises(KeyError, match="Level E "):
+                s.reset_index(level=["A", "E"])
+
+            # With single-level Index
+            s = df.set_index("A")["B"]
+
+            result = s.reset_index(level=levels[0])
+            tm.assert_frame_equal(result, df[["A", "B"]])
+
+            result = s.reset_index(level=levels[:1])
+            tm.assert_frame_equal(result, df[["A", "B"]])
+
+            result = s.reset_index(level=levels[0], drop=True)
+            tm.assert_series_equal(result, df["B"])
+
+            with pytest.raises(IndexError, match="Too many levels"):
+                s.reset_index(level=[0, 1, 2])
+
+        # Check that .reset_index([],drop=True) doesn't fail
+        result = Series(range(4)).reset_index([], drop=True)
+        expected = Series(range(4))
+        tm.assert_series_equal(result, expected)
+
+    def test_reset_index_range(self):
+        # GH 12071
+        s = Series(range(2), name="A", dtype="int64")
+        series_result = s.reset_index()
+        assert isinstance(series_result.index, RangeIndex)
+        series_expected = DataFrame(
+            [[0, 0], [1, 1]], columns=["index", "A"], index=RangeIndex(stop=2)
+        )
+        tm.assert_frame_equal(series_result, series_expected)
+
+    def test_reset_index_drop_errors(self):
+        #  GH 20925
+
+        # KeyError raised for series index when passed level name is missing
+        s = Series(range(4))
+        with pytest.raises(KeyError, match="does not match index name"):
+            s.reset_index("wrong", drop=True)
+        with pytest.raises(KeyError, match="does not match index name"):
+            s.reset_index("wrong")
+
+        # KeyError raised for series when level to be dropped is missing
+        s = Series(range(4), index=MultiIndex.from_product([[1, 2]] * 2))
+        with pytest.raises(KeyError, match="not found"):
+            s.reset_index("wrong", drop=True)
+
+    def test_reset_index_with_drop(self, series_with_multilevel_index):
+        ser = series_with_multilevel_index
+
+        deleveled = ser.reset_index()
+        assert isinstance(deleveled, DataFrame)
+        assert len(deleveled.columns) == len(ser.index.levels) + 1
+        assert deleveled.index.name == ser.index.name
+
+        deleveled = ser.reset_index(drop=True)
+        assert isinstance(deleveled, Series)
+        assert deleveled.index.name == ser.index.name
+
+    def test_reset_index_inplace_and_drop_ignore_name(self):
+        # GH#44575
+        ser = Series(range(2), name="old")
+        ser.reset_index(name="new", drop=True, inplace=True)
+        expected = Series(range(2), name="old")
+        tm.assert_series_equal(ser, expected)
+
+
+@pytest.mark.parametrize(
+    "array, dtype",
+    [
+        (["a", "b"], object),
+        (
+            pd.period_range("12-1-2000", periods=2, freq="Q-DEC"),
+            pd.PeriodDtype(freq="Q-DEC"),
+        ),
+    ],
+)
+def test_reset_index_dtypes_on_empty_series_with_multiindex(array, dtype):
+    # GH 19602 - Preserve dtype on empty Series with MultiIndex
+    idx = MultiIndex.from_product([[0, 1], [0.5, 1.0], array])
+    result = Series(dtype=object, index=idx)[:0].reset_index().dtypes
+    expected = Series(
+        {"level_0": np.int64, "level_1": np.float64, "level_2": dtype, 0: object}
+    )
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "names, expected_names",
+    [
+        (["A", "A"], ["A", "A"]),
+        (["level_1", None], ["level_1", "level_1"]),
+    ],
+)
+@pytest.mark.parametrize("allow_duplicates", [False, True])
+def test_column_name_duplicates(names, expected_names, allow_duplicates):
+    # GH#44755 reset_index with duplicate column labels
+    s = Series([1], index=MultiIndex.from_arrays([[1], [1]], names=names))
+    if allow_duplicates:
+        result = s.reset_index(allow_duplicates=True)
+        expected = DataFrame([[1, 1, 1]], columns=expected_names + [0])
+        tm.assert_frame_equal(result, expected)
+    else:
+        with pytest.raises(ValueError, match="cannot insert"):
+            s.reset_index()
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_round.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_round.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c40e3641955122079e93007ce3d162ce66a7976
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_round.py
@@ -0,0 +1,64 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesRound:
+    def test_round(self, datetime_series):
+        datetime_series.index.name = "index_name"
+        result = datetime_series.round(2)
+        expected = Series(
+            np.round(datetime_series.values, 2), index=datetime_series.index, name="ts"
+        )
+        tm.assert_series_equal(result, expected)
+        assert result.name == datetime_series.name
+
+    def test_round_numpy(self, any_float_dtype):
+        # See GH#12600
+        ser = Series([1.53, 1.36, 0.06], dtype=any_float_dtype)
+        out = np.round(ser, decimals=0)
+        expected = Series([2.0, 1.0, 0.0], dtype=any_float_dtype)
+        tm.assert_series_equal(out, expected)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.round(ser, decimals=0, out=ser)
+
+    def test_round_numpy_with_nan(self, any_float_dtype):
+        # See GH#14197
+        ser = Series([1.53, np.nan, 0.06], dtype=any_float_dtype)
+        with tm.assert_produces_warning(None):
+            result = ser.round()
+        expected = Series([2.0, np.nan, 0.0], dtype=any_float_dtype)
+        tm.assert_series_equal(result, expected)
+
+    def test_round_builtin(self, any_float_dtype):
+        ser = Series(
+            [1.123, 2.123, 3.123],
+            index=range(3),
+            dtype=any_float_dtype,
+        )
+        result = round(ser)
+        expected_rounded0 = Series(
+            [1.0, 2.0, 3.0], index=range(3), dtype=any_float_dtype
+        )
+        tm.assert_series_equal(result, expected_rounded0)
+
+        decimals = 2
+        expected_rounded = Series(
+            [1.12, 2.12, 3.12], index=range(3), dtype=any_float_dtype
+        )
+        result = round(ser, decimals)
+        tm.assert_series_equal(result, expected_rounded)
+
+    @pytest.mark.parametrize("method", ["round", "floor", "ceil"])
+    @pytest.mark.parametrize("freq", ["s", "5s", "min", "5min", "h", "5h"])
+    def test_round_nat(self, method, freq):
+        # GH14940
+        ser = Series([pd.NaT])
+        expected = Series(pd.NaT)
+        round_method = getattr(ser.dt, method)
+        tm.assert_series_equal(round_method(freq), expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_searchsorted.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_searchsorted.py
new file mode 100644
index 0000000000000000000000000000000000000000..239496052b99b42df262262a9ac89b71c93e0a26
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_searchsorted.py
@@ -0,0 +1,77 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.types import is_scalar
+
+
+class TestSeriesSearchSorted:
+    def test_searchsorted(self):
+        ser = Series([1, 2, 3])
+
+        result = ser.searchsorted(1, side="left")
+        assert is_scalar(result)
+        assert result == 0
+
+        result = ser.searchsorted(1, side="right")
+        assert is_scalar(result)
+        assert result == 1
+
+    def test_searchsorted_numeric_dtypes_scalar(self):
+        ser = Series([1, 2, 90, 1000, 3e9])
+        res = ser.searchsorted(30)
+        assert is_scalar(res)
+        assert res == 2
+
+        res = ser.searchsorted([30])
+        exp = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_numeric_dtypes_vector(self):
+        ser = Series([1, 2, 90, 1000, 3e9])
+        res = ser.searchsorted([91, 2e6])
+        exp = np.array([3, 4], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_datetime64_scalar(self):
+        ser = Series(date_range("20120101", periods=10, freq="2D"))
+        val = Timestamp("20120102")
+        res = ser.searchsorted(val)
+        assert is_scalar(res)
+        assert res == 1
+
+    def test_searchsorted_datetime64_scalar_mixed_timezones(self):
+        # GH 30086
+        ser = Series(date_range("20120101", periods=10, freq="2D", tz="UTC"))
+        val = Timestamp("20120102", tz="America/New_York")
+        res = ser.searchsorted(val)
+        assert is_scalar(res)
+        assert res == 1
+
+    def test_searchsorted_datetime64_list(self):
+        ser = Series(date_range("20120101", periods=10, freq="2D"))
+        vals = [Timestamp("20120102"), Timestamp("20120104")]
+        res = ser.searchsorted(vals)
+        exp = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_sorter(self):
+        # GH8490
+        ser = Series([3, 1, 2])
+        res = ser.searchsorted([0, 3], sorter=np.argsort(ser))
+        exp = np.array([0, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_searchsorted_dataframe_fail(self):
+        # GH#49620
+        ser = Series([1, 2, 3, 4, 5])
+        vals = pd.DataFrame([[1, 2], [3, 4]])
+        msg = "Value must be 1-D array-like or scalar, DataFrame is not supported"
+        with pytest.raises(ValueError, match=msg):
+            ser.searchsorted(vals)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_set_name.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_set_name.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbc8ebde7a8ab79fabe94781123844c856c9c78b
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_set_name.py
@@ -0,0 +1,21 @@
+from datetime import datetime
+
+from pandas import Series
+
+
+class TestSetName:
+    def test_set_name(self):
+        ser = Series([1, 2, 3])
+        ser2 = ser._set_name("foo")
+        assert ser2.name == "foo"
+        assert ser.name is None
+        assert ser is not ser2
+
+    def test_set_name_attribute(self):
+        ser = Series([1, 2, 3])
+        ser2 = Series([1, 2, 3], name="bar")
+        for name in [7, 7.0, "name", datetime(2001, 1, 1), (1,), "\u05D0"]:
+            ser.name = name
+            assert ser.name == name
+            ser2.name = name
+            assert ser2.name == name
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_size.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_size.py
new file mode 100644
index 0000000000000000000000000000000000000000..20a454996fa4488501d6f623ad3afc6fa38e5634
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_size.py
@@ -0,0 +1,22 @@
+import pytest
+
+from pandas import Series
+
+
+@pytest.mark.parametrize(
+    "data, index, expected",
+    [
+        ([1, 2, 3], None, 3),
+        ({"a": 1, "b": 2, "c": 3}, None, 3),
+        ([1, 2, 3], ["x", "y", "z"], 3),
+        ([1, 2, 3, 4, 5], ["x", "y", "z", "w", "n"], 5),
+        ([1, 2, 3], None, 3),
+        ([1, 2, 3], ["x", "y", "z"], 3),
+        ([1, 2, 3, 4], ["x", "y", "z", "w"], 4),
+    ],
+)
+def test_series(data, index, expected):
+    # GH#52897
+    ser = Series(data, index=index)
+    assert ser.size == expected
+    assert isinstance(ser.size, int)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_sort_index.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_sort_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5d4694f8bdbdbcd32ddc48cf896d852c96a827c
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_sort_index.py
@@ -0,0 +1,319 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DatetimeIndex,
+    IntervalIndex,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture(params=["quicksort", "mergesort", "heapsort", "stable"])
+def sort_kind(request):
+    return request.param
+
+
+class TestSeriesSortIndex:
+    def test_sort_index_name(self, datetime_series):
+        result = datetime_series.sort_index(ascending=False)
+        assert result.name == datetime_series.name
+
+    def test_sort_index(self, datetime_series):
+        datetime_series.index = datetime_series.index._with_freq(None)
+
+        rindex = list(datetime_series.index)
+        np.random.default_rng(2).shuffle(rindex)
+
+        random_order = datetime_series.reindex(rindex)
+        sorted_series = random_order.sort_index()
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        # descending
+        sorted_series = random_order.sort_index(ascending=False)
+        tm.assert_series_equal(
+            sorted_series, datetime_series.reindex(datetime_series.index[::-1])
+        )
+
+        # compat on level
+        sorted_series = random_order.sort_index(level=0)
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        # compat on axis
+        sorted_series = random_order.sort_index(axis=0)
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        msg = "No axis named 1 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            random_order.sort_values(axis=1)
+
+        sorted_series = random_order.sort_index(level=0, axis=0)
+        tm.assert_series_equal(sorted_series, datetime_series)
+
+        with pytest.raises(ValueError, match=msg):
+            random_order.sort_index(level=0, axis=1)
+
+    def test_sort_index_inplace(self, datetime_series):
+        datetime_series.index = datetime_series.index._with_freq(None)
+
+        # For GH#11402
+        rindex = list(datetime_series.index)
+        np.random.default_rng(2).shuffle(rindex)
+
+        # descending
+        random_order = datetime_series.reindex(rindex)
+        result = random_order.sort_index(ascending=False, inplace=True)
+
+        assert result is None
+        expected = datetime_series.reindex(datetime_series.index[::-1])
+        expected.index = expected.index._with_freq(None)
+        tm.assert_series_equal(random_order, expected)
+
+        # ascending
+        random_order = datetime_series.reindex(rindex)
+        result = random_order.sort_index(ascending=True, inplace=True)
+
+        assert result is None
+        expected = datetime_series.copy()
+        expected.index = expected.index._with_freq(None)
+        tm.assert_series_equal(random_order, expected)
+
+    def test_sort_index_level(self):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        s = Series([1, 2], mi)
+        backwards = s.iloc[[1, 0]]
+
+        res = s.sort_index(level="A")
+        tm.assert_series_equal(backwards, res)
+
+        res = s.sort_index(level=["A", "B"])
+        tm.assert_series_equal(backwards, res)
+
+        res = s.sort_index(level="A", sort_remaining=False)
+        tm.assert_series_equal(s, res)
+
+        res = s.sort_index(level=["A", "B"], sort_remaining=False)
+        tm.assert_series_equal(s, res)
+
+    @pytest.mark.parametrize("level", ["A", 0])  # GH#21052
+    def test_sort_index_multiindex(self, level):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        s = Series([1, 2], mi)
+        backwards = s.iloc[[1, 0]]
+
+        # implicit sort_remaining=True
+        res = s.sort_index(level=level)
+        tm.assert_series_equal(backwards, res)
+
+        # GH#13496
+        # sort has no effect without remaining lvls
+        res = s.sort_index(level=level, sort_remaining=False)
+        tm.assert_series_equal(s, res)
+
+    def test_sort_index_kind(self, sort_kind):
+        # GH#14444 & GH#13589:  Add support for sort algo choosing
+        series = Series(index=[3, 2, 1, 4, 3], dtype=object)
+        expected_series = Series(index=[1, 2, 3, 3, 4], dtype=object)
+
+        index_sorted_series = series.sort_index(kind=sort_kind)
+        tm.assert_series_equal(expected_series, index_sorted_series)
+
+    def test_sort_index_na_position(self):
+        series = Series(index=[3, 2, 1, 4, 3, np.nan], dtype=object)
+        expected_series_first = Series(index=[np.nan, 1, 2, 3, 3, 4], dtype=object)
+
+        index_sorted_series = series.sort_index(na_position="first")
+        tm.assert_series_equal(expected_series_first, index_sorted_series)
+
+        expected_series_last = Series(index=[1, 2, 3, 3, 4, np.nan], dtype=object)
+
+        index_sorted_series = series.sort_index(na_position="last")
+        tm.assert_series_equal(expected_series_last, index_sorted_series)
+
+    def test_sort_index_intervals(self):
+        s = Series(
+            [np.nan, 1, 2, 3], IntervalIndex.from_arrays([0, 1, 2, 3], [1, 2, 3, 4])
+        )
+
+        result = s.sort_index()
+        expected = s
+        tm.assert_series_equal(result, expected)
+
+        result = s.sort_index(ascending=False)
+        expected = Series(
+            [3, 2, 1, np.nan], IntervalIndex.from_arrays([3, 2, 1, 0], [4, 3, 2, 1])
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_list, sorted_list, ascending, ignore_index, output_index",
+        [
+            ([2, 3, 6, 1], [2, 3, 6, 1], True, True, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [2, 3, 6, 1], True, False, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [1, 6, 3, 2], False, True, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [1, 6, 3, 2], False, False, [3, 2, 1, 0]),
+        ],
+    )
+    def test_sort_index_ignore_index(
+        self, inplace, original_list, sorted_list, ascending, ignore_index, output_index
+    ):
+        # GH 30114
+        ser = Series(original_list)
+        expected = Series(sorted_list, index=output_index)
+        kwargs = {
+            "ascending": ascending,
+            "ignore_index": ignore_index,
+            "inplace": inplace,
+        }
+
+        if inplace:
+            result_ser = ser.copy()
+            result_ser.sort_index(**kwargs)
+        else:
+            result_ser = ser.sort_index(**kwargs)
+
+        tm.assert_series_equal(result_ser, expected)
+        tm.assert_series_equal(ser, Series(original_list))
+
+    def test_sort_index_ascending_list(self):
+        # GH#16934
+
+        # Set up a Series with a three level MultiIndex
+        arrays = [
+            ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+            ["one", "two", "one", "two", "one", "two", "one", "two"],
+            [4, 3, 2, 1, 4, 3, 2, 1],
+        ]
+        tuples = zip(*arrays)
+        mi = MultiIndex.from_tuples(tuples, names=["first", "second", "third"])
+        ser = Series(range(8), index=mi)
+
+        # Sort with boolean ascending
+        result = ser.sort_index(level=["third", "first"], ascending=False)
+        expected = ser.iloc[[4, 0, 5, 1, 6, 2, 7, 3]]
+        tm.assert_series_equal(result, expected)
+
+        # Sort with list of boolean ascending
+        result = ser.sort_index(level=["third", "first"], ascending=[False, True])
+        expected = ser.iloc[[0, 4, 1, 5, 2, 6, 3, 7]]
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "ascending",
+        [
+            None,
+            (True, None),
+            (False, "True"),
+        ],
+    )
+    def test_sort_index_ascending_bad_value_raises(self, ascending):
+        ser = Series(range(10), index=[0, 3, 2, 1, 4, 5, 7, 6, 8, 9])
+        match = 'For argument "ascending" expected type bool'
+        with pytest.raises(ValueError, match=match):
+            ser.sort_index(ascending=ascending)
+
+
+class TestSeriesSortIndexKey:
+    def test_sort_index_multiindex_key(self):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        s = Series([1, 2], mi)
+        backwards = s.iloc[[1, 0]]
+
+        result = s.sort_index(level="C", key=lambda x: -x)
+        tm.assert_series_equal(s, result)
+
+        result = s.sort_index(level="C", key=lambda x: x)  # nothing happens
+        tm.assert_series_equal(backwards, result)
+
+    def test_sort_index_multiindex_key_multi_level(self):
+        mi = MultiIndex.from_tuples([[1, 1, 3], [1, 1, 1]], names=list("ABC"))
+        s = Series([1, 2], mi)
+        backwards = s.iloc[[1, 0]]
+
+        result = s.sort_index(level=["A", "C"], key=lambda x: -x)
+        tm.assert_series_equal(s, result)
+
+        result = s.sort_index(level=["A", "C"], key=lambda x: x)  # nothing happens
+        tm.assert_series_equal(backwards, result)
+
+    def test_sort_index_key(self):
+        series = Series(np.arange(6, dtype="int64"), index=list("aaBBca"))
+
+        result = series.sort_index()
+        expected = series.iloc[[2, 3, 0, 1, 5, 4]]
+        tm.assert_series_equal(result, expected)
+
+        result = series.sort_index(key=lambda x: x.str.lower())
+        expected = series.iloc[[0, 1, 5, 2, 3, 4]]
+        tm.assert_series_equal(result, expected)
+
+        result = series.sort_index(key=lambda x: x.str.lower(), ascending=False)
+        expected = series.iloc[[4, 2, 3, 0, 1, 5]]
+        tm.assert_series_equal(result, expected)
+
+    def test_sort_index_key_int(self):
+        series = Series(np.arange(6, dtype="int64"), index=np.arange(6, dtype="int64"))
+
+        result = series.sort_index()
+        tm.assert_series_equal(result, series)
+
+        result = series.sort_index(key=lambda x: -x)
+        expected = series.sort_index(ascending=False)
+        tm.assert_series_equal(result, expected)
+
+        result = series.sort_index(key=lambda x: 2 * x)
+        tm.assert_series_equal(result, series)
+
+    def test_sort_index_kind_key(self, sort_kind, sort_by_key):
+        # GH #14444 & #13589:  Add support for sort algo choosing
+        series = Series(index=[3, 2, 1, 4, 3], dtype=object)
+        expected_series = Series(index=[1, 2, 3, 3, 4], dtype=object)
+
+        index_sorted_series = series.sort_index(kind=sort_kind, key=sort_by_key)
+        tm.assert_series_equal(expected_series, index_sorted_series)
+
+    def test_sort_index_kind_neg_key(self, sort_kind):
+        # GH #14444 & #13589:  Add support for sort algo choosing
+        series = Series(index=[3, 2, 1, 4, 3], dtype=object)
+        expected_series = Series(index=[4, 3, 3, 2, 1], dtype=object)
+
+        index_sorted_series = series.sort_index(kind=sort_kind, key=lambda x: -x)
+        tm.assert_series_equal(expected_series, index_sorted_series)
+
+    def test_sort_index_na_position_key(self, sort_by_key):
+        series = Series(index=[3, 2, 1, 4, 3, np.nan], dtype=object)
+        expected_series_first = Series(index=[np.nan, 1, 2, 3, 3, 4], dtype=object)
+
+        index_sorted_series = series.sort_index(na_position="first", key=sort_by_key)
+        tm.assert_series_equal(expected_series_first, index_sorted_series)
+
+        expected_series_last = Series(index=[1, 2, 3, 3, 4, np.nan], dtype=object)
+
+        index_sorted_series = series.sort_index(na_position="last", key=sort_by_key)
+        tm.assert_series_equal(expected_series_last, index_sorted_series)
+
+    def test_changes_length_raises(self):
+        s = Series([1, 2, 3])
+        with pytest.raises(ValueError, match="change the shape"):
+            s.sort_index(key=lambda x: x[:1])
+
+    def test_sort_values_key_type(self):
+        s = Series([1, 2, 3], DatetimeIndex(["2008-10-24", "2008-11-23", "2007-12-22"]))
+
+        result = s.sort_index(key=lambda x: x.month)
+        expected = s.iloc[[0, 1, 2]]
+        tm.assert_series_equal(result, expected)
+
+        result = s.sort_index(key=lambda x: x.day)
+        expected = s.iloc[[2, 1, 0]]
+        tm.assert_series_equal(result, expected)
+
+        result = s.sort_index(key=lambda x: x.year)
+        expected = s.iloc[[2, 0, 1]]
+        tm.assert_series_equal(result, expected)
+
+        result = s.sort_index(key=lambda x: x.month_name())
+        expected = s.iloc[[2, 1, 0]]
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_sort_values.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_sort_values.py
new file mode 100644
index 0000000000000000000000000000000000000000..4808272879071e8530c000daddbe7e9518deaefc
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_sort_values.py
@@ -0,0 +1,246 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestSeriesSortValues:
+    def test_sort_values(self, datetime_series, using_copy_on_write):
+        # check indexes are reordered corresponding with the values
+        ser = Series([3, 2, 4, 1], ["A", "B", "C", "D"])
+        expected = Series([1, 2, 3, 4], ["D", "B", "A", "C"])
+        result = ser.sort_values()
+        tm.assert_series_equal(expected, result)
+
+        ts = datetime_series.copy()
+        ts[:5] = np.nan
+        vals = ts.values
+
+        result = ts.sort_values()
+        assert np.isnan(result[-5:]).all()
+        tm.assert_numpy_array_equal(result[:-5].values, np.sort(vals[5:]))
+
+        # na_position
+        result = ts.sort_values(na_position="first")
+        assert np.isnan(result[:5]).all()
+        tm.assert_numpy_array_equal(result[5:].values, np.sort(vals[5:]))
+
+        # something object-type
+        ser = Series(["A", "B"], [1, 2])
+        # no failure
+        ser.sort_values()
+
+        # ascending=False
+        ordered = ts.sort_values(ascending=False)
+        expected = np.sort(ts.dropna().values)[::-1]
+        tm.assert_almost_equal(expected, ordered.dropna().values)
+        ordered = ts.sort_values(ascending=False, na_position="first")
+        tm.assert_almost_equal(expected, ordered.dropna().values)
+
+        # ascending=[False] should behave the same as ascending=False
+        ordered = ts.sort_values(ascending=[False])
+        expected = ts.sort_values(ascending=False)
+        tm.assert_series_equal(expected, ordered)
+        ordered = ts.sort_values(ascending=[False], na_position="first")
+        expected = ts.sort_values(ascending=False, na_position="first")
+        tm.assert_series_equal(expected, ordered)
+
+        msg = 'For argument "ascending" expected type bool, received type NoneType.'
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values(ascending=None)
+        msg = r"Length of ascending \(0\) must be 1 for Series"
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values(ascending=[])
+        msg = r"Length of ascending \(3\) must be 1 for Series"
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values(ascending=[1, 2, 3])
+        msg = r"Length of ascending \(2\) must be 1 for Series"
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values(ascending=[False, False])
+        msg = 'For argument "ascending" expected type bool, received type str.'
+        with pytest.raises(ValueError, match=msg):
+            ts.sort_values(ascending="foobar")
+
+        # inplace=True
+        ts = datetime_series.copy()
+        return_value = ts.sort_values(ascending=False, inplace=True)
+        assert return_value is None
+        tm.assert_series_equal(ts, datetime_series.sort_values(ascending=False))
+        tm.assert_index_equal(
+            ts.index, datetime_series.sort_values(ascending=False).index
+        )
+
+        # GH#5856/5853
+        # Series.sort_values operating on a view
+        df = DataFrame(np.random.default_rng(2).standard_normal((10, 4)))
+        s = df.iloc[:, 0]
+
+        msg = (
+            "This Series is a view of some other array, to sort in-place "
+            "you must create a copy"
+        )
+        if using_copy_on_write:
+            s.sort_values(inplace=True)
+            tm.assert_series_equal(s, df.iloc[:, 0].sort_values())
+        else:
+            with pytest.raises(ValueError, match=msg):
+                s.sort_values(inplace=True)
+
+    def test_sort_values_categorical(self):
+        c = Categorical(["a", "b", "b", "a"], ordered=False)
+        cat = Series(c.copy())
+
+        # sort in the categories order
+        expected = Series(
+            Categorical(["a", "a", "b", "b"], ordered=False), index=[0, 3, 1, 2]
+        )
+        result = cat.sort_values()
+        tm.assert_series_equal(result, expected)
+
+        cat = Series(Categorical(["a", "c", "b", "d"], ordered=True))
+        res = cat.sort_values()
+        exp = np.array(["a", "b", "c", "d"], dtype=np.object_)
+        tm.assert_numpy_array_equal(res.__array__(), exp)
+
+        cat = Series(
+            Categorical(
+                ["a", "c", "b", "d"], categories=["a", "b", "c", "d"], ordered=True
+            )
+        )
+        res = cat.sort_values()
+        exp = np.array(["a", "b", "c", "d"], dtype=np.object_)
+        tm.assert_numpy_array_equal(res.__array__(), exp)
+
+        res = cat.sort_values(ascending=False)
+        exp = np.array(["d", "c", "b", "a"], dtype=np.object_)
+        tm.assert_numpy_array_equal(res.__array__(), exp)
+
+        raw_cat1 = Categorical(
+            ["a", "b", "c", "d"], categories=["a", "b", "c", "d"], ordered=False
+        )
+        raw_cat2 = Categorical(
+            ["a", "b", "c", "d"], categories=["d", "c", "b", "a"], ordered=True
+        )
+        s = ["a", "b", "c", "d"]
+        df = DataFrame(
+            {"unsort": raw_cat1, "sort": raw_cat2, "string": s, "values": [1, 2, 3, 4]}
+        )
+
+        # Cats must be sorted in a dataframe
+        res = df.sort_values(by=["string"], ascending=False)
+        exp = np.array(["d", "c", "b", "a"], dtype=np.object_)
+        tm.assert_numpy_array_equal(res["sort"].values.__array__(), exp)
+        assert res["sort"].dtype == "category"
+
+        res = df.sort_values(by=["sort"], ascending=False)
+        exp = df.sort_values(by=["string"], ascending=True)
+        tm.assert_series_equal(res["values"], exp["values"])
+        assert res["sort"].dtype == "category"
+        assert res["unsort"].dtype == "category"
+
+        # unordered cat, but we allow this
+        df.sort_values(by=["unsort"], ascending=False)
+
+        # multi-columns sort
+        # GH#7848
+        df = DataFrame(
+            {"id": [6, 5, 4, 3, 2, 1], "raw_grade": ["a", "b", "b", "a", "a", "e"]}
+        )
+        df["grade"] = Categorical(df["raw_grade"], ordered=True)
+        df["grade"] = df["grade"].cat.set_categories(["b", "e", "a"])
+
+        # sorts 'grade' according to the order of the categories
+        result = df.sort_values(by=["grade"])
+        expected = df.iloc[[1, 2, 5, 0, 3, 4]]
+        tm.assert_frame_equal(result, expected)
+
+        # multi
+        result = df.sort_values(by=["grade", "id"])
+        expected = df.iloc[[2, 1, 5, 4, 3, 0]]
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("inplace", [True, False])
+    @pytest.mark.parametrize(
+        "original_list, sorted_list, ignore_index, output_index",
+        [
+            ([2, 3, 6, 1], [6, 3, 2, 1], True, [0, 1, 2, 3]),
+            ([2, 3, 6, 1], [6, 3, 2, 1], False, [2, 1, 0, 3]),
+        ],
+    )
+    def test_sort_values_ignore_index(
+        self, inplace, original_list, sorted_list, ignore_index, output_index
+    ):
+        # GH 30114
+        ser = Series(original_list)
+        expected = Series(sorted_list, index=output_index)
+        kwargs = {"ignore_index": ignore_index, "inplace": inplace}
+
+        if inplace:
+            result_ser = ser.copy()
+            result_ser.sort_values(ascending=False, **kwargs)
+        else:
+            result_ser = ser.sort_values(ascending=False, **kwargs)
+
+        tm.assert_series_equal(result_ser, expected)
+        tm.assert_series_equal(ser, Series(original_list))
+
+    def test_mergesort_descending_stability(self):
+        # GH 28697
+        s = Series([1, 2, 1, 3], ["first", "b", "second", "c"])
+        result = s.sort_values(ascending=False, kind="mergesort")
+        expected = Series([3, 2, 1, 1], ["c", "b", "first", "second"])
+        tm.assert_series_equal(result, expected)
+
+    def test_sort_values_validate_ascending_for_value_error(self):
+        # GH41634
+        ser = Series([23, 7, 21])
+
+        msg = 'For argument "ascending" expected type bool, received type str.'
+        with pytest.raises(ValueError, match=msg):
+            ser.sort_values(ascending="False")
+
+    @pytest.mark.parametrize("ascending", [False, 0, 1, True])
+    def test_sort_values_validate_ascending_functional(self, ascending):
+        # GH41634
+        ser = Series([23, 7, 21])
+        expected = np.sort(ser.values)
+
+        sorted_ser = ser.sort_values(ascending=ascending)
+        if not ascending:
+            expected = expected[::-1]
+
+        result = sorted_ser.values
+        tm.assert_numpy_array_equal(result, expected)
+
+
+class TestSeriesSortingKey:
+    def test_sort_values_key(self):
+        series = Series(np.array(["Hello", "goodbye"]))
+
+        result = series.sort_values(axis=0)
+        expected = series
+        tm.assert_series_equal(result, expected)
+
+        result = series.sort_values(axis=0, key=lambda x: x.str.lower())
+        expected = series[::-1]
+        tm.assert_series_equal(result, expected)
+
+    def test_sort_values_key_nan(self):
+        series = Series(np.array([0, 5, np.nan, 3, 2, np.nan]))
+
+        result = series.sort_values(axis=0)
+        expected = series.iloc[[0, 4, 3, 1, 2, 5]]
+        tm.assert_series_equal(result, expected)
+
+        result = series.sort_values(axis=0, key=lambda x: x + 5)
+        expected = series.iloc[[0, 4, 3, 1, 2, 5]]
+        tm.assert_series_equal(result, expected)
+
+        result = series.sort_values(axis=0, key=lambda x: -x, ascending=False)
+        expected = series.iloc[[0, 4, 3, 1, 2, 5]]
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_csv.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_csv.py
new file mode 100644
index 0000000000000000000000000000000000000000..76ca05a60eb7a02c4d71b4b8c68b410edb2d1fe5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_csv.py
@@ -0,0 +1,180 @@
+from datetime import datetime
+from io import StringIO
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+from pandas.io.common import get_handle
+
+
+class TestSeriesToCSV:
+    def read_csv(self, path, **kwargs):
+        params = {"index_col": 0, "header": None}
+        params.update(**kwargs)
+
+        header = params.get("header")
+        out = pd.read_csv(path, **params).squeeze("columns")
+
+        if header is None:
+            out.name = out.index.name = None
+
+        return out
+
+    def test_from_csv(self, datetime_series, string_series):
+        # freq doesn't round-trip
+        datetime_series.index = datetime_series.index._with_freq(None)
+
+        with tm.ensure_clean() as path:
+            datetime_series.to_csv(path, header=False)
+            ts = self.read_csv(path, parse_dates=True)
+            tm.assert_series_equal(datetime_series, ts, check_names=False)
+
+            assert ts.name is None
+            assert ts.index.name is None
+
+            # see gh-10483
+            datetime_series.to_csv(path, header=True)
+            ts_h = self.read_csv(path, header=0)
+            assert ts_h.name == "ts"
+
+            string_series.to_csv(path, header=False)
+            series = self.read_csv(path)
+            tm.assert_series_equal(string_series, series, check_names=False)
+
+            assert series.name is None
+            assert series.index.name is None
+
+            string_series.to_csv(path, header=True)
+            series_h = self.read_csv(path, header=0)
+            assert series_h.name == "series"
+
+            with open(path, "w", encoding="utf-8") as outfile:
+                outfile.write("1998-01-01|1.0\n1999-01-01|2.0")
+
+            series = self.read_csv(path, sep="|", parse_dates=True)
+            check_series = Series(
+                {datetime(1998, 1, 1): 1.0, datetime(1999, 1, 1): 2.0}
+            )
+            tm.assert_series_equal(check_series, series)
+
+            series = self.read_csv(path, sep="|", parse_dates=False)
+            check_series = Series({"1998-01-01": 1.0, "1999-01-01": 2.0})
+            tm.assert_series_equal(check_series, series)
+
+    def test_to_csv(self, datetime_series):
+        with tm.ensure_clean() as path:
+            datetime_series.to_csv(path, header=False)
+
+            with open(path, newline=None, encoding="utf-8") as f:
+                lines = f.readlines()
+            assert lines[1] != "\n"
+
+            datetime_series.to_csv(path, index=False, header=False)
+            arr = np.loadtxt(path)
+            tm.assert_almost_equal(arr, datetime_series.values)
+
+    def test_to_csv_unicode_index(self):
+        buf = StringIO()
+        s = Series(["\u05d0", "d2"], index=["\u05d0", "\u05d1"])
+
+        s.to_csv(buf, encoding="UTF-8", header=False)
+        buf.seek(0)
+
+        s2 = self.read_csv(buf, index_col=0, encoding="UTF-8")
+        tm.assert_series_equal(s, s2)
+
+    def test_to_csv_float_format(self):
+        with tm.ensure_clean() as filename:
+            ser = Series([0.123456, 0.234567, 0.567567])
+            ser.to_csv(filename, float_format="%.2f", header=False)
+
+            rs = self.read_csv(filename)
+            xp = Series([0.12, 0.23, 0.57])
+            tm.assert_series_equal(rs, xp)
+
+    def test_to_csv_list_entries(self):
+        s = Series(["jack and jill", "jesse and frank"])
+
+        split = s.str.split(r"\s+and\s+")
+
+        buf = StringIO()
+        split.to_csv(buf, header=False)
+
+    def test_to_csv_path_is_none(self):
+        # GH 8215
+        # Series.to_csv() was returning None, inconsistent with
+        # DataFrame.to_csv() which returned string
+        s = Series([1, 2, 3])
+        csv_str = s.to_csv(path_or_buf=None, header=False)
+        assert isinstance(csv_str, str)
+
+    @pytest.mark.parametrize(
+        "s,encoding",
+        [
+            (
+                Series([0.123456, 0.234567, 0.567567], index=["A", "B", "C"], name="X"),
+                None,
+            ),
+            # GH 21241, 21118
+            (Series(["abc", "def", "ghi"], name="X"), "ascii"),
+            (Series(["123", "你好", "世界"], name="中文"), "gb2312"),
+            (
+                Series(["123", "Γειά σου", "Κόσμε"], name="Ελληνικά"),  # noqa: RUF001
+                "cp737",
+            ),
+        ],
+    )
+    def test_to_csv_compression(self, s, encoding, compression):
+        with tm.ensure_clean() as filename:
+            s.to_csv(filename, compression=compression, encoding=encoding, header=True)
+            # test the round trip - to_csv -> read_csv
+            result = pd.read_csv(
+                filename,
+                compression=compression,
+                encoding=encoding,
+                index_col=0,
+            ).squeeze("columns")
+            tm.assert_series_equal(s, result)
+
+            # test the round trip using file handle - to_csv -> read_csv
+            with get_handle(
+                filename, "w", compression=compression, encoding=encoding
+            ) as handles:
+                s.to_csv(handles.handle, encoding=encoding, header=True)
+
+            result = pd.read_csv(
+                filename,
+                compression=compression,
+                encoding=encoding,
+                index_col=0,
+            ).squeeze("columns")
+            tm.assert_series_equal(s, result)
+
+            # explicitly ensure file was compressed
+            with tm.decompress_file(filename, compression) as fh:
+                text = fh.read().decode(encoding or "utf8")
+                assert s.name in text
+
+            with tm.decompress_file(filename, compression) as fh:
+                tm.assert_series_equal(
+                    s,
+                    pd.read_csv(fh, index_col=0, encoding=encoding).squeeze("columns"),
+                )
+
+    def test_to_csv_interval_index(self):
+        # GH 28210
+        s = Series(["foo", "bar", "baz"], index=pd.interval_range(0, 3))
+
+        with tm.ensure_clean("__tmp_to_csv_interval_index__.csv") as path:
+            s.to_csv(path, header=False)
+            result = self.read_csv(path, index_col=0)
+
+            # can't roundtrip intervalindex via read_csv so check string repr (GH 23595)
+            expected = s.copy()
+            expected.index = expected.index.astype(str)
+
+            tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_dict.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_dict.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c3d9592eebe3fa6c08ae8b970e6c252d1e882d4
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_dict.py
@@ -0,0 +1,38 @@
+import collections
+
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesToDict:
+    @pytest.mark.parametrize(
+        "mapping", (dict, collections.defaultdict(list), collections.OrderedDict)
+    )
+    def test_to_dict(self, mapping, datetime_series):
+        # GH#16122
+        result = Series(datetime_series.to_dict(mapping), name="ts")
+        expected = datetime_series.copy()
+        expected.index = expected.index._with_freq(None)
+        tm.assert_series_equal(result, expected)
+
+        from_method = Series(datetime_series.to_dict(collections.Counter))
+        from_constructor = Series(collections.Counter(datetime_series.items()))
+        tm.assert_series_equal(from_method, from_constructor)
+
+    @pytest.mark.parametrize(
+        "input",
+        (
+            {"a": np.int64(64), "b": 10},
+            {"a": np.int64(64), "b": 10, "c": "ABC"},
+            {"a": np.uint64(64), "b": 10, "c": "ABC"},
+        ),
+    )
+    def test_to_dict_return_types(self, input):
+        # GH25969
+
+        d = Series(input).to_dict()
+        assert isinstance(d["a"], int)
+        assert isinstance(d["b"], int)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_frame.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_frame.py
new file mode 100644
index 0000000000000000000000000000000000000000..0eadf696b34cc034d2be76ce5daba2cff679da74
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_frame.py
@@ -0,0 +1,63 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestToFrame:
+    def test_to_frame_respects_name_none(self):
+        # GH#44212 if we explicitly pass name=None, then that should be respected,
+        #  not changed to 0
+        # GH-45448 this is first deprecated & enforced in 2.0
+        ser = Series(range(3))
+        result = ser.to_frame(None)
+
+        exp_index = Index([None], dtype=object)
+        tm.assert_index_equal(result.columns, exp_index)
+
+        result = ser.rename("foo").to_frame(None)
+        exp_index = Index([None], dtype=object)
+        tm.assert_index_equal(result.columns, exp_index)
+
+    def test_to_frame(self, datetime_series):
+        datetime_series.name = None
+        rs = datetime_series.to_frame()
+        xp = DataFrame(datetime_series.values, index=datetime_series.index)
+        tm.assert_frame_equal(rs, xp)
+
+        datetime_series.name = "testname"
+        rs = datetime_series.to_frame()
+        xp = DataFrame(
+            {"testname": datetime_series.values}, index=datetime_series.index
+        )
+        tm.assert_frame_equal(rs, xp)
+
+        rs = datetime_series.to_frame(name="testdifferent")
+        xp = DataFrame(
+            {"testdifferent": datetime_series.values}, index=datetime_series.index
+        )
+        tm.assert_frame_equal(rs, xp)
+
+    @pytest.mark.filterwarnings(
+        "ignore:Passing a BlockManager|Passing a SingleBlockManager:DeprecationWarning"
+    )
+    def test_to_frame_expanddim(self):
+        # GH#9762
+
+        class SubclassedSeries(Series):
+            @property
+            def _constructor_expanddim(self):
+                return SubclassedFrame
+
+        class SubclassedFrame(DataFrame):
+            pass
+
+        ser = SubclassedSeries([1, 2, 3], name="X")
+        result = ser.to_frame()
+        assert isinstance(result, SubclassedFrame)
+        expected = SubclassedFrame({"X": [1, 2, 3]})
+        tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_numpy.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fe3e19b0a20bbfcf7caafa811af133c5b07fed5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_to_numpy.py
@@ -0,0 +1,25 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    Series,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("dtype", ["int64", "float64"])
+def test_to_numpy_na_value(dtype):
+    # GH#48951
+    ser = Series([1, 2, NA, 4])
+    result = ser.to_numpy(dtype=dtype, na_value=0)
+    expected = np.array([1, 2, 0, 4], dtype=dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_to_numpy_cast_before_setting_na():
+    # GH#50600
+    ser = Series([1])
+    result = ser.to_numpy(dtype=np.float64, na_value=np.nan)
+    expected = np.array([1.0])
+    tm.assert_numpy_array_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_tolist.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_tolist.py
new file mode 100644
index 0000000000000000000000000000000000000000..4af473528e23850794139ac563cc04c6d3c54617
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_tolist.py
@@ -0,0 +1,36 @@
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    Interval,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+)
+
+
+@pytest.mark.parametrize(
+    "values, dtype, expected_dtype",
+    (
+        ([1], "int64", int),
+        ([1], "Int64", int),
+        ([1.0], "float64", float),
+        ([1.0], "Float64", float),
+        (["abc"], "object", str),
+        (["abc"], "string", str),
+        ([Interval(1, 3)], "interval", Interval),
+        ([Period("2000-01-01", "D")], "period[D]", Period),
+        ([Timedelta(days=1)], "timedelta64[ns]", Timedelta),
+        ([Timestamp("2000-01-01")], "datetime64[ns]", Timestamp),
+        pytest.param([1], "int64[pyarrow]", int, marks=td.skip_if_no("pyarrow")),
+        pytest.param([1.0], "float64[pyarrow]", float, marks=td.skip_if_no("pyarrow")),
+        pytest.param(["abc"], "string[pyarrow]", str, marks=td.skip_if_no("pyarrow")),
+    ),
+)
+def test_tolist_scalar_dtype(values, dtype, expected_dtype):
+    # GH49890
+    ser = Series(values, dtype=dtype)
+    result_dtype = type(ser.tolist()[0])
+    assert result_dtype == expected_dtype
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_truncate.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_truncate.py
new file mode 100644
index 0000000000000000000000000000000000000000..33eb5c10ae163862e342b1871669d64d74602e4e
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_truncate.py
@@ -0,0 +1,67 @@
+from datetime import datetime
+
+import pytest
+
+import pandas as pd
+from pandas import (
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestTruncate:
+    def test_truncate_datetimeindex_tz(self):
+        # GH 9243
+        idx = date_range("4/1/2005", "4/30/2005", freq="D", tz="US/Pacific")
+        s = Series(range(len(idx)), index=idx)
+        with pytest.raises(TypeError, match="Cannot compare tz-naive"):
+            # GH#36148 as of 2.0 we require tzawareness compat
+            s.truncate(datetime(2005, 4, 2), datetime(2005, 4, 4))
+
+        lb = idx[1]
+        ub = idx[3]
+        result = s.truncate(lb.to_pydatetime(), ub.to_pydatetime())
+        expected = Series([1, 2, 3], index=idx[1:4])
+        tm.assert_series_equal(result, expected)
+
+    def test_truncate_periodindex(self):
+        # GH 17717
+        idx1 = pd.PeriodIndex(
+            [pd.Period("2017-09-02"), pd.Period("2017-09-02"), pd.Period("2017-09-03")]
+        )
+        series1 = Series([1, 2, 3], index=idx1)
+        result1 = series1.truncate(after="2017-09-02")
+
+        expected_idx1 = pd.PeriodIndex(
+            [pd.Period("2017-09-02"), pd.Period("2017-09-02")]
+        )
+        tm.assert_series_equal(result1, Series([1, 2], index=expected_idx1))
+
+        idx2 = pd.PeriodIndex(
+            [pd.Period("2017-09-03"), pd.Period("2017-09-02"), pd.Period("2017-09-03")]
+        )
+        series2 = Series([1, 2, 3], index=idx2)
+        result2 = series2.sort_index().truncate(after="2017-09-02")
+
+        expected_idx2 = pd.PeriodIndex([pd.Period("2017-09-02")])
+        tm.assert_series_equal(result2, Series([2], index=expected_idx2))
+
+    def test_truncate_one_element_series(self):
+        # GH 35544
+        series = Series([0.1], index=pd.DatetimeIndex(["2020-08-04"]))
+        before = pd.Timestamp("2020-08-02")
+        after = pd.Timestamp("2020-08-04")
+
+        result = series.truncate(before=before, after=after)
+
+        # the input Series and the expected Series are the same
+        tm.assert_series_equal(result, series)
+
+    def test_truncate_index_only_one_unique_value(self):
+        # GH 42365
+        obj = Series(0, index=date_range("2021-06-30", "2021-06-30")).repeat(5)
+
+        truncated = obj.truncate("2021-06-28", "2021-07-01")
+
+        tm.assert_series_equal(truncated, obj)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_tz_localize.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_tz_localize.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2b1569d3f3918c19115c49d38953ec3eb5581de
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_tz_localize.py
@@ -0,0 +1,123 @@
+from datetime import timezone
+
+import pytest
+import pytz
+
+from pandas._libs.tslibs import timezones
+
+from pandas import (
+    DatetimeIndex,
+    NaT,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestTZLocalize:
+    def test_series_tz_localize_ambiguous_bool(self):
+        # make sure that we are correctly accepting bool values as ambiguous
+
+        # GH#14402
+        ts = Timestamp("2015-11-01 01:00:03")
+        expected0 = Timestamp("2015-11-01 01:00:03-0500", tz="US/Central")
+        expected1 = Timestamp("2015-11-01 01:00:03-0600", tz="US/Central")
+
+        ser = Series([ts])
+        expected0 = Series([expected0])
+        expected1 = Series([expected1])
+
+        with tm.external_error_raised(pytz.AmbiguousTimeError):
+            ser.dt.tz_localize("US/Central")
+
+        result = ser.dt.tz_localize("US/Central", ambiguous=True)
+        tm.assert_series_equal(result, expected0)
+
+        result = ser.dt.tz_localize("US/Central", ambiguous=[True])
+        tm.assert_series_equal(result, expected0)
+
+        result = ser.dt.tz_localize("US/Central", ambiguous=False)
+        tm.assert_series_equal(result, expected1)
+
+        result = ser.dt.tz_localize("US/Central", ambiguous=[False])
+        tm.assert_series_equal(result, expected1)
+
+    def test_series_tz_localize_matching_index(self):
+        # Matching the index of the result with that of the original series
+        # GH 43080
+        dt_series = Series(
+            date_range(start="2021-01-01T02:00:00", periods=5, freq="1D"),
+            index=[2, 6, 7, 8, 11],
+            dtype="category",
+        )
+        result = dt_series.dt.tz_localize("Europe/Berlin")
+        expected = Series(
+            date_range(
+                start="2021-01-01T02:00:00", periods=5, freq="1D", tz="Europe/Berlin"
+            ),
+            index=[2, 6, 7, 8, 11],
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "method, exp",
+        [
+            ["shift_forward", "2015-03-29 03:00:00"],
+            ["shift_backward", "2015-03-29 01:59:59.999999999"],
+            ["NaT", NaT],
+            ["raise", None],
+            ["foo", "invalid"],
+        ],
+    )
+    def test_tz_localize_nonexistent(self, warsaw, method, exp):
+        # GH 8917
+        tz = warsaw
+        n = 60
+        dti = date_range(start="2015-03-29 02:00:00", periods=n, freq="min")
+        ser = Series(1, index=dti)
+        df = ser.to_frame()
+
+        if method == "raise":
+            with tm.external_error_raised(pytz.NonExistentTimeError):
+                dti.tz_localize(tz, nonexistent=method)
+            with tm.external_error_raised(pytz.NonExistentTimeError):
+                ser.tz_localize(tz, nonexistent=method)
+            with tm.external_error_raised(pytz.NonExistentTimeError):
+                df.tz_localize(tz, nonexistent=method)
+
+        elif exp == "invalid":
+            msg = (
+                "The nonexistent argument must be one of "
+                "'raise', 'NaT', 'shift_forward', 'shift_backward' "
+                "or a timedelta object"
+            )
+            with pytest.raises(ValueError, match=msg):
+                dti.tz_localize(tz, nonexistent=method)
+            with pytest.raises(ValueError, match=msg):
+                ser.tz_localize(tz, nonexistent=method)
+            with pytest.raises(ValueError, match=msg):
+                df.tz_localize(tz, nonexistent=method)
+
+        else:
+            result = ser.tz_localize(tz, nonexistent=method)
+            expected = Series(1, index=DatetimeIndex([exp] * n, tz=tz))
+            tm.assert_series_equal(result, expected)
+
+            result = df.tz_localize(tz, nonexistent=method)
+            expected = expected.to_frame()
+            tm.assert_frame_equal(result, expected)
+
+            res_index = dti.tz_localize(tz, nonexistent=method)
+            tm.assert_index_equal(res_index, expected.index)
+
+    @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_series_tz_localize_empty(self, tzstr):
+        # GH#2248
+        ser = Series(dtype=object)
+
+        ser2 = ser.tz_localize("utc")
+        assert ser2.index.tz == timezone.utc
+
+        ser2 = ser.tz_localize(tzstr)
+        timezones.tz_compare(ser2.index.tz, timezones.maybe_get_tz(tzstr))
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_unique.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_unique.py
new file mode 100644
index 0000000000000000000000000000000000000000..14e247332503253ede23e94fe1335e712a2675e7
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_unique.py
@@ -0,0 +1,76 @@
+import numpy as np
+
+from pandas import (
+    Categorical,
+    IntervalIndex,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestUnique:
+    def test_unique_uint64(self):
+        ser = Series([1, 2, 2**63, 2**63], dtype=np.uint64)
+        res = ser.unique()
+        exp = np.array([1, 2, 2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_unique_data_ownership(self):
+        # it works! GH#1807
+        Series(Series(["a", "c", "b"]).unique()).sort_values()
+
+    def test_unique(self):
+        # GH#714 also, dtype=float
+        ser = Series([1.2345] * 100)
+        ser[::2] = np.nan
+        result = ser.unique()
+        assert len(result) == 2
+
+        # explicit f4 dtype
+        ser = Series([1.2345] * 100, dtype="f4")
+        ser[::2] = np.nan
+        result = ser.unique()
+        assert len(result) == 2
+
+    def test_unique_nan_object_dtype(self):
+        # NAs in object arrays GH#714
+        ser = Series(["foo"] * 100, dtype="O")
+        ser[::2] = np.nan
+        result = ser.unique()
+        assert len(result) == 2
+
+    def test_unique_none(self):
+        # decision about None
+        ser = Series([1, 2, 3, None, None, None], dtype=object)
+        result = ser.unique()
+        expected = np.array([1, 2, 3, None], dtype=object)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_unique_categorical(self):
+        # GH#18051
+        cat = Categorical([])
+        ser = Series(cat)
+        result = ser.unique()
+        tm.assert_categorical_equal(result, cat)
+
+        cat = Categorical([np.nan])
+        ser = Series(cat)
+        result = ser.unique()
+        tm.assert_categorical_equal(result, cat)
+
+    def test_tz_unique(self):
+        # GH 46128
+        dti1 = date_range("2016-01-01", periods=3)
+        ii1 = IntervalIndex.from_breaks(dti1)
+        ser1 = Series(ii1)
+        uni1 = ser1.unique()
+        tm.assert_interval_array_equal(ser1.array, uni1)
+
+        dti2 = date_range("2016-01-01", periods=3, tz="US/Eastern")
+        ii2 = IntervalIndex.from_breaks(dti2)
+        ser2 = Series(ii2)
+        uni2 = ser2.unique()
+        tm.assert_interval_array_equal(ser2.array, uni2)
+
+        assert uni1.dtype != uni2.dtype
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_unstack.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_unstack.py
new file mode 100644
index 0000000000000000000000000000000000000000..b294e2fcce9d8f752d738363b592b099051f7adc
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_unstack.py
@@ -0,0 +1,164 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_unstack_preserves_object():
+    mi = MultiIndex.from_product([["bar", "foo"], ["one", "two"]])
+
+    ser = Series(np.arange(4.0), index=mi, dtype=object)
+
+    res1 = ser.unstack()
+    assert (res1.dtypes == object).all()
+
+    res2 = ser.unstack(level=0)
+    assert (res2.dtypes == object).all()
+
+
+def test_unstack():
+    index = MultiIndex(
+        levels=[["bar", "foo"], ["one", "three", "two"]],
+        codes=[[1, 1, 0, 0], [0, 1, 0, 2]],
+    )
+
+    s = Series(np.arange(4.0), index=index)
+    unstacked = s.unstack()
+
+    expected = DataFrame(
+        [[2.0, np.nan, 3.0], [0.0, 1.0, np.nan]],
+        index=["bar", "foo"],
+        columns=["one", "three", "two"],
+    )
+
+    tm.assert_frame_equal(unstacked, expected)
+
+    unstacked = s.unstack(level=0)
+    tm.assert_frame_equal(unstacked, expected.T)
+
+    index = MultiIndex(
+        levels=[["bar"], ["one", "two", "three"], [0, 1]],
+        codes=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+    )
+    s = Series(np.random.default_rng(2).standard_normal(6), index=index)
+    exp_index = MultiIndex(
+        levels=[["one", "two", "three"], [0, 1]],
+        codes=[[0, 1, 2, 0, 1, 2], [0, 1, 0, 1, 0, 1]],
+    )
+    expected = DataFrame({"bar": s.values}, index=exp_index).sort_index(level=0)
+    unstacked = s.unstack(0).sort_index()
+    tm.assert_frame_equal(unstacked, expected)
+
+    # GH5873
+    idx = MultiIndex.from_arrays([[101, 102], [3.5, np.nan]])
+    ts = Series([1, 2], index=idx)
+    left = ts.unstack()
+    right = DataFrame(
+        [[np.nan, 1], [2, np.nan]], index=[101, 102], columns=[np.nan, 3.5]
+    )
+    tm.assert_frame_equal(left, right)
+
+    idx = MultiIndex.from_arrays(
+        [
+            ["cat", "cat", "cat", "dog", "dog"],
+            ["a", "a", "b", "a", "b"],
+            [1, 2, 1, 1, np.nan],
+        ]
+    )
+    ts = Series([1.0, 1.1, 1.2, 1.3, 1.4], index=idx)
+    right = DataFrame(
+        [[1.0, 1.3], [1.1, np.nan], [np.nan, 1.4], [1.2, np.nan]],
+        columns=["cat", "dog"],
+    )
+    tpls = [("a", 1), ("a", 2), ("b", np.nan), ("b", 1)]
+    right.index = MultiIndex.from_tuples(tpls)
+    tm.assert_frame_equal(ts.unstack(level=0), right)
+
+
+def test_unstack_tuplename_in_multiindex():
+    # GH 19966
+    idx = MultiIndex.from_product(
+        [["a", "b", "c"], [1, 2, 3]], names=[("A", "a"), ("B", "b")]
+    )
+    ser = Series(1, index=idx)
+    result = ser.unstack(("A", "a"))
+
+    expected = DataFrame(
+        [[1, 1, 1], [1, 1, 1], [1, 1, 1]],
+        columns=MultiIndex.from_tuples([("a",), ("b",), ("c",)], names=[("A", "a")]),
+        index=pd.Index([1, 2, 3], name=("B", "b")),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "unstack_idx, expected_values, expected_index, expected_columns",
+    [
+        (
+            ("A", "a"),
+            [[1, 1], [1, 1], [1, 1], [1, 1]],
+            MultiIndex.from_tuples([(1, 3), (1, 4), (2, 3), (2, 4)], names=["B", "C"]),
+            MultiIndex.from_tuples([("a",), ("b",)], names=[("A", "a")]),
+        ),
+        (
+            (("A", "a"), "B"),
+            [[1, 1, 1, 1], [1, 1, 1, 1]],
+            pd.Index([3, 4], name="C"),
+            MultiIndex.from_tuples(
+                [("a", 1), ("a", 2), ("b", 1), ("b", 2)], names=[("A", "a"), "B"]
+            ),
+        ),
+    ],
+)
+def test_unstack_mixed_type_name_in_multiindex(
+    unstack_idx, expected_values, expected_index, expected_columns
+):
+    # GH 19966
+    idx = MultiIndex.from_product(
+        [["a", "b"], [1, 2], [3, 4]], names=[("A", "a"), "B", "C"]
+    )
+    ser = Series(1, index=idx)
+    result = ser.unstack(unstack_idx)
+
+    expected = DataFrame(
+        expected_values, columns=expected_columns, index=expected_index
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_unstack_multi_index_categorical_values():
+    mi = (
+        tm.makeTimeDataFrame().stack(future_stack=True).index.rename(["major", "minor"])
+    )
+    ser = Series(["foo"] * len(mi), index=mi, name="category", dtype="category")
+
+    result = ser.unstack()
+
+    dti = ser.index.levels[0]
+    c = pd.Categorical(["foo"] * len(dti))
+    expected = DataFrame(
+        {"A": c.copy(), "B": c.copy(), "C": c.copy(), "D": c.copy()},
+        columns=pd.Index(list("ABCD"), name="minor"),
+        index=dti.rename("major"),
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_unstack_mixed_level_names():
+    # GH#48763
+    arrays = [["a", "a"], [1, 2], ["red", "blue"]]
+    idx = MultiIndex.from_arrays(arrays, names=("x", 0, "y"))
+    ser = Series([1, 2], index=idx)
+    result = ser.unstack("x")
+    expected = DataFrame(
+        [[1], [2]],
+        columns=pd.Index(["a"], name="x"),
+        index=MultiIndex.from_tuples([(1, "red"), (2, "blue")], names=[0, "y"]),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_update.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_update.py
new file mode 100644
index 0000000000000000000000000000000000000000..c38b2400f0f4e011809f6d49a72fe68cffacc7e5
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_update.py
@@ -0,0 +1,137 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import (
+    CategoricalDtype,
+    DataFrame,
+    NaT,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+class TestUpdate:
+    def test_update(self, using_copy_on_write):
+        s = Series([1.5, np.nan, 3.0, 4.0, np.nan])
+        s2 = Series([np.nan, 3.5, np.nan, 5.0])
+        s.update(s2)
+
+        expected = Series([1.5, 3.5, 3.0, 5.0, np.nan])
+        tm.assert_series_equal(s, expected)
+
+        # GH 3217
+        df = DataFrame([{"a": 1}, {"a": 3, "b": 2}])
+        df["c"] = np.nan
+        # Cast to object to avoid upcast when setting "foo"
+        df["c"] = df["c"].astype(object)
+        df_orig = df.copy()
+
+        if using_copy_on_write:
+            with tm.raises_chained_assignment_error():
+                df["c"].update(Series(["foo"], index=[0]))
+            expected = df_orig
+        else:
+            df["c"].update(Series(["foo"], index=[0]))
+            expected = DataFrame(
+                [[1, np.nan, "foo"], [3, 2.0, np.nan]], columns=["a", "b", "c"]
+            )
+        tm.assert_frame_equal(df, expected)
+
+    @pytest.mark.parametrize(
+        "other, dtype, expected, warn",
+        [
+            # other is int
+            ([61, 63], "int32", Series([10, 61, 12], dtype="int32"), None),
+            ([61, 63], "int64", Series([10, 61, 12]), None),
+            ([61, 63], float, Series([10.0, 61.0, 12.0]), None),
+            ([61, 63], object, Series([10, 61, 12], dtype=object), None),
+            # other is float, but can be cast to int
+            ([61.0, 63.0], "int32", Series([10, 61, 12], dtype="int32"), None),
+            ([61.0, 63.0], "int64", Series([10, 61, 12]), None),
+            ([61.0, 63.0], float, Series([10.0, 61.0, 12.0]), None),
+            ([61.0, 63.0], object, Series([10, 61.0, 12], dtype=object), None),
+            # others is float, cannot be cast to int
+            ([61.1, 63.1], "int32", Series([10.0, 61.1, 12.0]), FutureWarning),
+            ([61.1, 63.1], "int64", Series([10.0, 61.1, 12.0]), FutureWarning),
+            ([61.1, 63.1], float, Series([10.0, 61.1, 12.0]), None),
+            ([61.1, 63.1], object, Series([10, 61.1, 12], dtype=object), None),
+            # other is object, cannot be cast
+            ([(61,), (63,)], "int32", Series([10, (61,), 12]), FutureWarning),
+            ([(61,), (63,)], "int64", Series([10, (61,), 12]), FutureWarning),
+            ([(61,), (63,)], float, Series([10.0, (61,), 12.0]), FutureWarning),
+            ([(61,), (63,)], object, Series([10, (61,), 12]), None),
+        ],
+    )
+    def test_update_dtypes(self, other, dtype, expected, warn):
+        ser = Series([10, 11, 12], dtype=dtype)
+        other = Series(other, index=[1, 3])
+        with tm.assert_produces_warning(warn, match="item of incompatible dtype"):
+            ser.update(other)
+
+        tm.assert_series_equal(ser, expected)
+
+    @pytest.mark.parametrize(
+        "series, other, expected",
+        [
+            # update by key
+            (
+                Series({"a": 1, "b": 2, "c": 3, "d": 4}),
+                {"b": 5, "c": np.nan},
+                Series({"a": 1, "b": 5, "c": 3, "d": 4}),
+            ),
+            # update by position
+            (Series([1, 2, 3, 4]), [np.nan, 5, 1], Series([1, 5, 1, 4])),
+        ],
+    )
+    def test_update_from_non_series(self, series, other, expected):
+        # GH 33215
+        series.update(other)
+        tm.assert_series_equal(series, expected)
+
+    @pytest.mark.parametrize(
+        "data, other, expected, dtype",
+        [
+            (["a", None], [None, "b"], ["a", "b"], "string[python]"),
+            pytest.param(
+                ["a", None],
+                [None, "b"],
+                ["a", "b"],
+                "string[pyarrow]",
+                marks=td.skip_if_no("pyarrow"),
+            ),
+            ([1, None], [None, 2], [1, 2], "Int64"),
+            ([True, None], [None, False], [True, False], "boolean"),
+            (
+                ["a", None],
+                [None, "b"],
+                ["a", "b"],
+                CategoricalDtype(categories=["a", "b"]),
+            ),
+            (
+                [Timestamp(year=2020, month=1, day=1, tz="Europe/London"), NaT],
+                [NaT, Timestamp(year=2020, month=1, day=1, tz="Europe/London")],
+                [Timestamp(year=2020, month=1, day=1, tz="Europe/London")] * 2,
+                "datetime64[ns, Europe/London]",
+            ),
+        ],
+    )
+    def test_update_extension_array_series(self, data, other, expected, dtype):
+        result = Series(data, dtype=dtype)
+        other = Series(other, dtype=dtype)
+        expected = Series(expected, dtype=dtype)
+
+        result.update(other)
+        tm.assert_series_equal(result, expected)
+
+    def test_update_with_categorical_type(self):
+        # GH 25744
+        dtype = CategoricalDtype(["a", "b", "c", "d"])
+        s1 = Series(["a", "b", "c"], index=[1, 2, 3], dtype=dtype)
+        s2 = Series(["b", "a"], index=[1, 2], dtype=dtype)
+        s1.update(s2)
+        result = s1
+        expected = Series(["b", "a", "c"], index=[1, 2, 3], dtype=dtype)
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_value_counts.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_value_counts.py
new file mode 100644
index 0000000000000000000000000000000000000000..f54489ac8a8b401d4168221c1d901cf06de73b60
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_value_counts.py
@@ -0,0 +1,252 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+class TestSeriesValueCounts:
+    def test_value_counts_datetime(self):
+        # most dtypes are tested in tests/base
+        values = [
+            pd.Timestamp("2011-01-01 09:00"),
+            pd.Timestamp("2011-01-01 10:00"),
+            pd.Timestamp("2011-01-01 11:00"),
+            pd.Timestamp("2011-01-01 09:00"),
+            pd.Timestamp("2011-01-01 09:00"),
+            pd.Timestamp("2011-01-01 11:00"),
+        ]
+
+        exp_idx = pd.DatetimeIndex(
+            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
+            name="xxx",
+        )
+        exp = Series([3, 2, 1], index=exp_idx, name="count")
+
+        ser = Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check DatetimeIndex outputs the same result
+        idx = pd.DatetimeIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_datetime_tz(self):
+        values = [
+            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
+            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
+        ]
+
+        exp_idx = pd.DatetimeIndex(
+            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
+            tz="US/Eastern",
+            name="xxx",
+        )
+        exp = Series([3, 2, 1], index=exp_idx, name="count")
+
+        ser = Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        idx = pd.DatetimeIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_period(self):
+        values = [
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2011-02", freq="M"),
+            pd.Period("2011-03", freq="M"),
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2011-01", freq="M"),
+            pd.Period("2011-03", freq="M"),
+        ]
+
+        exp_idx = pd.PeriodIndex(
+            ["2011-01", "2011-03", "2011-02"], freq="M", name="xxx"
+        )
+        exp = Series([3, 2, 1], index=exp_idx, name="count")
+
+        ser = Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check DatetimeIndex outputs the same result
+        idx = pd.PeriodIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_categorical_ordered(self):
+        # most dtypes are tested in tests/base
+        values = Categorical([1, 2, 3, 1, 1, 3], ordered=True)
+
+        exp_idx = CategoricalIndex(
+            [1, 3, 2], categories=[1, 2, 3], ordered=True, name="xxx"
+        )
+        exp = Series([3, 2, 1], index=exp_idx, name="count")
+
+        ser = Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check CategoricalIndex outputs the same result
+        idx = CategoricalIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_categorical_not_ordered(self):
+        values = Categorical([1, 2, 3, 1, 1, 3], ordered=False)
+
+        exp_idx = CategoricalIndex(
+            [1, 3, 2], categories=[1, 2, 3], ordered=False, name="xxx"
+        )
+        exp = Series([3, 2, 1], index=exp_idx, name="count")
+
+        ser = Series(values, name="xxx")
+        tm.assert_series_equal(ser.value_counts(), exp)
+        # check CategoricalIndex outputs the same result
+        idx = CategoricalIndex(values, name="xxx")
+        tm.assert_series_equal(idx.value_counts(), exp)
+
+        # normalize
+        exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion")
+        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
+        tm.assert_series_equal(idx.value_counts(normalize=True), exp)
+
+    def test_value_counts_categorical(self):
+        # GH#12835
+        cats = Categorical(list("abcccb"), categories=list("cabd"))
+        ser = Series(cats, name="xxx")
+        res = ser.value_counts(sort=False)
+
+        exp_index = CategoricalIndex(
+            list("cabd"), categories=cats.categories, name="xxx"
+        )
+        exp = Series([3, 1, 2, 0], name="count", index=exp_index)
+        tm.assert_series_equal(res, exp)
+
+        res = ser.value_counts(sort=True)
+
+        exp_index = CategoricalIndex(
+            list("cbad"), categories=cats.categories, name="xxx"
+        )
+        exp = Series([3, 2, 1, 0], name="count", index=exp_index)
+        tm.assert_series_equal(res, exp)
+
+        # check object dtype handles the Series.name as the same
+        # (tested in tests/base)
+        ser = Series(["a", "b", "c", "c", "c", "b"], name="xxx")
+        res = ser.value_counts()
+        exp = Series([3, 2, 1], name="count", index=Index(["c", "b", "a"], name="xxx"))
+        tm.assert_series_equal(res, exp)
+
+    def test_value_counts_categorical_with_nan(self):
+        # see GH#9443
+
+        # sanity check
+        ser = Series(["a", "b", "a"], dtype="category")
+        exp = Series([2, 1], index=CategoricalIndex(["a", "b"]), name="count")
+
+        res = ser.value_counts(dropna=True)
+        tm.assert_series_equal(res, exp)
+
+        res = ser.value_counts(dropna=True)
+        tm.assert_series_equal(res, exp)
+
+        # same Series via two different constructions --> same behaviour
+        series = [
+            Series(["a", "b", None, "a", None, None], dtype="category"),
+            Series(
+                Categorical(["a", "b", None, "a", None, None], categories=["a", "b"])
+            ),
+        ]
+
+        for ser in series:
+            # None is a NaN value, so we exclude its count here
+            exp = Series([2, 1], index=CategoricalIndex(["a", "b"]), name="count")
+            res = ser.value_counts(dropna=True)
+            tm.assert_series_equal(res, exp)
+
+            # we don't exclude the count of None and sort by counts
+            exp = Series(
+                [3, 2, 1], index=CategoricalIndex([np.nan, "a", "b"]), name="count"
+            )
+            res = ser.value_counts(dropna=False)
+            tm.assert_series_equal(res, exp)
+
+            # When we aren't sorting by counts, and np.nan isn't a
+            # category, it should be last.
+            exp = Series(
+                [2, 1, 3], index=CategoricalIndex(["a", "b", np.nan]), name="count"
+            )
+            res = ser.value_counts(dropna=False, sort=False)
+            tm.assert_series_equal(res, exp)
+
+    @pytest.mark.parametrize(
+        "ser, dropna, exp",
+        [
+            (
+                Series([False, True, True, pd.NA]),
+                False,
+                Series([2, 1, 1], index=[True, False, pd.NA], name="count"),
+            ),
+            (
+                Series([False, True, True, pd.NA]),
+                True,
+                Series([2, 1], index=Index([True, False], dtype=object), name="count"),
+            ),
+            (
+                Series(range(3), index=[True, False, np.nan]).index,
+                False,
+                Series([1, 1, 1], index=[True, False, np.nan], name="count"),
+            ),
+        ],
+    )
+    def test_value_counts_bool_with_nan(self, ser, dropna, exp):
+        # GH32146
+        out = ser.value_counts(dropna=dropna)
+        tm.assert_series_equal(out, exp)
+
+    @pytest.mark.parametrize(
+        "input_array,expected",
+        [
+            (
+                [1 + 1j, 1 + 1j, 1, 3j, 3j, 3j],
+                Series(
+                    [3, 2, 1],
+                    index=Index([3j, 1 + 1j, 1], dtype=np.complex128),
+                    name="count",
+                ),
+            ),
+            (
+                np.array([1 + 1j, 1 + 1j, 1, 3j, 3j, 3j], dtype=np.complex64),
+                Series(
+                    [3, 2, 1],
+                    index=Index([3j, 1 + 1j, 1], dtype=np.complex64),
+                    name="count",
+                ),
+            ),
+        ],
+    )
+    def test_value_counts_complex_numbers(self, input_array, expected):
+        # GH 17927
+        result = Series(input_array).value_counts()
+        tm.assert_series_equal(result, expected)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_values.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_values.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb1595e68264fbe5f07b014be4975657fa2fa8cf
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_values.py
@@ -0,0 +1,29 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    IntervalIndex,
+    Series,
+    period_range,
+)
+import pandas._testing as tm
+
+
+class TestValues:
+    @pytest.mark.parametrize(
+        "data",
+        [
+            period_range("2000", periods=4),
+            IntervalIndex.from_breaks([1, 2, 3, 4]),
+        ],
+    )
+    def test_values_object_extension_dtypes(self, data):
+        # https://github.com/pandas-dev/pandas/issues/23995
+        result = Series(data).values
+        expected = np.array(data.astype(object))
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_values(self, datetime_series):
+        tm.assert_almost_equal(
+            datetime_series.values, list(datetime_series), check_dtype=False
+        )
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_view.py b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_view.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9b29c9329193675512ee77e697a063096af2a33
--- /dev/null
+++ b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/series/methods/test_view.py
@@ -0,0 +1,57 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Index,
+    Series,
+    array,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestView:
+    def test_view_i8_to_datetimelike(self):
+        dti = date_range("2000", periods=4, tz="US/Central")
+        ser = Series(dti.asi8)
+
+        result = ser.view(dti.dtype)
+        tm.assert_datetime_array_equal(result._values, dti._data._with_freq(None))
+
+        pi = dti.tz_localize(None).to_period("D")
+        ser = Series(pi.asi8)
+        result = ser.view(pi.dtype)
+        tm.assert_period_array_equal(result._values, pi._data)
+
+    def test_view_tz(self):
+        # GH#24024
+        ser = Series(date_range("2000", periods=4, tz="US/Central"))
+        result = ser.view("i8")
+        expected = Series(
+            [
+                946706400000000000,
+                946792800000000000,
+                946879200000000000,
+                946965600000000000,
+            ]
+        )
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "first", ["m8[ns]", "M8[ns]", "M8[ns, US/Central]", "period[D]"]
+    )
+    @pytest.mark.parametrize(
+        "second", ["m8[ns]", "M8[ns]", "M8[ns, US/Central]", "period[D]"]
+    )
+    @pytest.mark.parametrize("box", [Series, Index, array])
+    def test_view_between_datetimelike(self, first, second, box):
+        dti = date_range("2016-01-01", periods=3)
+
+        orig = box(dti)
+        obj = orig.view(first)
+        assert obj.dtype == first
+        tm.assert_numpy_array_equal(np.asarray(obj.view("i8")), dti.asi8)
+
+        res = obj.view(second)
+        assert res.dtype == second
+        tm.assert_numpy_array_equal(np.asarray(obj.view("i8")), dti.asi8)
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e127c5ee12c533a3ce9120e3103785e141f1dee
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_api.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_api.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e5b047189b17416b7c93b5dab867989ff491d9e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_api.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_array_to_datetime.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_array_to_datetime.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bcab7b0fab64e84535aa9beb4dfe248700f7e8e9
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_array_to_datetime.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_ccalendar.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_ccalendar.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4581dd924d626b38f57709a570e9da2040a6b62a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_ccalendar.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_conversion.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_conversion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cca8dd42d363994f82459a91e294b783fc04602
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_conversion.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_fields.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_fields.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa7d681bc5ebc864c5d27d917788195a1701ca64
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_fields.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_libfrequencies.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_libfrequencies.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a97cf3a0f09926f1b88073a0d2d990fc412f25e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_libfrequencies.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_liboffsets.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_liboffsets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..24a2f1bed60f89ec3361c882cb65b198a9ba634d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_liboffsets.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_np_datetime.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_np_datetime.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e79be135286713ddf7ad297a4b4cfbbefc83663
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_np_datetime.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_parse_iso8601.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_parse_iso8601.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a7b2aca58d3174c2976388335d69e0d2785233c
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_parse_iso8601.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_parsing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_parsing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a499028187feeb6d0171c9f81c46bcbaec117330
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_parsing.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_period_asfreq.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_period_asfreq.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ea11bd184284431c802ed7a97a251202ab7da70
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_period_asfreq.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_resolution.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_resolution.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d722f03f056ae0dbf4df2bc493f655a84a1b2f9b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_resolution.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_timedeltas.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_timedeltas.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1fa743096c091c30294c0a1bf847620c760db038
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_timedeltas.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_timezones.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_timezones.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e55dcdb499563978a3616bda894d946c27511e1
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_timezones.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_to_offset.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_to_offset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b320517bbd29221f14c9b95c89ef5e7112fcb596
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_to_offset.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_tzconversion.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_tzconversion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dd777de7c0278beddde3ebff40939aadcbcf50e
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/tslibs/__pycache__/test_tzconversion.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/__init__.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac8595d4a91b7ae79af15795a2bea66009650c58
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/__init__.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/conftest.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/conftest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..515a1797ba2d86d98f5557d901a825950273acba
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/conftest.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..740870d00e172653d9e6bb6afc7c08bb96d2631a
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..47775577b7e79e28930afad77d50a87f791f71d3
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_attr_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ea680d7a973822f4507853291b9a5ef9c6599c7
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f70913dee23618ce0aa9f296d3c945326d2a4468
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_extension_array_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..566e0cca3445b8182f98a1e8708748cb2d102ea0
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_frame_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_index_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_index_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..277d512ed1ae1a73afb1dc715c37510af9502fbf
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_index_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bad4b549ea05132526779dee03287ffe5ce8fee6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_interval_array_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c4c0a2c6b629a2907b6be568a69a417d06b4c8d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..054f8bb50d7dc6de1fa581695ffa4adb47dc38f5
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_produces_warning.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_series_equal.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_series_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..023952ee08cf85602b719a0cc690c8d41e41f937
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_assert_series_equal.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6ea9614c56ac1411b379308d9d7f41e44778855
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2af224d8aa20f565f6b2c49433eb779c545ea2f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate_kwarg.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate_nonkeyword_arguments.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate_nonkeyword_arguments.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..adb65246140f558c3528830f62d59da957a56664
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_deprecate_nonkeyword_arguments.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5cc3d8ff6d8f8f11a2b6b7b0f076cfc048c5ac4
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_hashing.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_hashing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6df5928e8f25608dd49cd5cfad27c88c0293779f
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_hashing.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_make_objects.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_make_objects.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1543e41a7ae9e78e4238531d5cb182f32ffc7943
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_make_objects.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_numba.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_numba.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..640427a08d921ad2b110654b31faadc1bb986f66
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_numba.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a3d928977b47613ab50e81caca873b48775ccf6
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_safe_import.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_safe_import.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01ccc73830b110f5501195b2794ebe8bcb2bd5e8
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_safe_import.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_shares_memory.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_shares_memory.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8a1844fcd719d05110774eea6a8b157c6b9dfaf
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_shares_memory.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7b01f3213d8d9a9f65bf8ecebe73110b8a0b21d
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_util.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..240ff981da52447ffc3c6673123343c4bcceb2aa
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_util.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_args.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_args.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..106d7183e01c7f321754f26ddc72983cbfccc88b
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_args.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b63d4a2d5b25fd998ed666dabe3f94a445dd2cec
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_args_and_kwargs.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_inclusive.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_inclusive.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2e91bf14ecc85a5427e8e7d94d864b3d8598f65
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_inclusive.cpython-312.pyc differ
diff --git a/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_kwargs.cpython-312.pyc b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_kwargs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7832b2f617e285d385655053a95635e4e06ffcee
Binary files /dev/null and b/platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/tests/util/__pycache__/test_validate_kwargs.cpython-312.pyc differ